@canonry/canonry 7.87.2 → 7.90.0

package/dist/{chunk-IVGVPPQT.js → chunk-OVUFIG22.js}

@@ -1,7 +1,7 @@
 import {
   answerServiceAdapters,
   answerServiceDescriptors
-} from "./chunk-IK7QEKKD.js";
+} from "./chunk-TA4L7U2M.js";
 import {
   AeroLlmUsageFeatures,
   aeroTurnStatus,
@@ -27,14 +27,14 @@ import {
   resolveConfiguredAgentProvider,
   resolveSessionProviderAndModel,
   setAeroSystemPrompt
-} from "./chunk-T2MGGW6Y.js";
+} from "./chunk-NKGQCCUS.js";
 import {
   AeroToolProfiles,
   AeroToolScopes,
   buildAeroStateTools,
   isAeroToolProfile,
   truncateToolResult
-} from "./chunk-TFB2S6TQ.js";
+} from "./chunk-DF4B6OGX.js";
 import {
   getGoogleAuthConfig,
   getGoogleConnection,
@@ -53,7 +53,7 @@ import {
   removeCloudflareTrafficConnection,
   removeCloudflareTrafficConnectionBySourceId,
   upsertCloudflareTrafficConnection
-} from "./chunk-4FWDITQG.js";
+} from "./chunk-UG7TZJIG.js";
 import {
   claudeAdapter,
   embedQueries,
@@ -65,7 +65,7 @@ import {
   openrouterAdapter,
   perplexityAdapter,
   startTrafficReclassification
-} from "./chunk-BVJA3TV2.js";
+} from "./chunk-I7DAEE3L.js";
 import {
   classifyUsageSurface,
   createApiUsageTelemetry,
@@ -77,7 +77,7 @@ import {
   startOutcomeTimer,
   trackFeatureCompleted,
   trackInstallState
-} from "./chunk-6F5ULQDY.js";
+} from "./chunk-DZO6CATO.js";
 import {
   isLoopbackBindHost
 } from "./chunk-TSENU4GG.js";
@@ -85,7 +85,7 @@ import {
   isApiProviderRegistrable,
   isCdpProviderRegistrable,
   registeredProviderNames
-} from "./chunk-3KK6FWDF.js";
+} from "./chunk-LQWMNDZR.js";
 import {
   checkLatestVersionForServer,
   getOrCreateAnonymousId,
@@ -97,17 +97,17 @@ import {
   recordDashboardEvent,
   setTelemetryPreference,
   trackEvent
-} from "./chunk-DOPUEXMC.js";
+} from "./chunk-AFYKUX2X.js";
 import {
   createCanonryMcpServer
-} from "./chunk-ICS2WJ7H.js";
+} from "./chunk-7VJJXLRP.js";
 import {
   CANONRY_MCP_TIERS,
   CANONRY_MCP_TOOLKIT_NAMES
 } from "./chunk-MTW37GXF.js";
 import {
   ApiClient
-} from "./chunk-TEQF4ZJA.js";
+} from "./chunk-F6WNKKGG.js";
 import {
   AGENT_PROVIDERS,
   adapterSupportsBatch,
@@ -139,21 +139,21 @@ import {
   saveConfigPatch,
   sentimentInstallReadiness,
   updateSharedProviderExecutionGate
-} from "./chunk-2FJB3CSS.js";
+} from "./chunk-OOVWMWMT.js";
 import {
   getBundledSkillSnapshots
-} from "./chunk-FAMCDCVK.js";
+} from "./chunk-Q6EZEVXE.js";
 import {
   computeFactorAverages,
   deleteSiteCrawlGraphLayout,
   persistSiteCrawlGraphLayout,
   prepareSiteCrawlGraphLayout,
   recordedSharePct
-} from "./chunk-ZJVQ72VC.js";
+} from "./chunk-N7LRPMWR.js";
 import {
   CanonryMcpToolNames,
   canonryMcpTools
-} from "./chunk-TN53B5AB.js";
+} from "./chunk-WNDBACO7.js";
 import {
   PACKAGE_VERSION
 } from "./chunk-AOJU5LKX.js";
@@ -162,16 +162,16 @@ import {
 } from "./chunk-HGMYEDAQ.js";
 import {
   IntelligenceService
-} from "./chunk-ZCNKGBIV.js";
+} from "./chunk-YB2GAK32.js";
 import {
   computeCitedCompetitorDomains,
   determineCitationState
-} from "./chunk-JAYUWQAV.js";
+} from "./chunk-GKX5F7NX.js";
 import {
   addLogListener,
   createFastifyLogger,
   createLogger
-} from "./chunk-IBGZ6D6R.js";
+} from "./chunk-XCEA5OMI.js";
 import {
   BingApiError,
   CC_CACHE_DIR,
@@ -199,6 +199,9 @@ import {
   auditFromRequest,
   backfillProjectAnswerMentions,
   backfillProjectAnswerMentionsInChunks,
+  bingDateToDay,
+  bingKeywordMarket,
+  bingPositionOrNull,
   blockedAddressReason,
   buildLocationProfileFields,
   captureSimpleMeasurementDefinition,
@@ -222,13 +225,31 @@ import {
   fetchDailyMetrics,
   fetchSearchAnalytics,
   formatStorefrontAddress,
+  getActivePagePreviewBlocks,
   getAttributes,
   getAuthUrl,
+  getBlockedUrls,
+  getConnectedPages,
+  getContentSubmissionQuota,
+  getCountryRegionSettings,
   getCrawlIssues,
+  getCrawlSettings,
+  getCrawlStats,
+  getDeepLinkBlocks,
+  getFeedDetails,
+  getFeeds,
+  getFetchedUrls,
+  getKeywordHistory,
   getLodging,
+  getPageStats,
   getPlaceDetails,
   getPlaceReviewSignals,
+  getQueryParameters,
+  getQueryStats,
+  getRankAndTrafficStats,
+  getSiteRoles,
   getUrlInfo,
+  getUrlSubmissionQuota,
   hasOutstandingProviderBatch,
   hasProxyHeaders,
   hashApiKey,
@@ -238,6 +259,7 @@ import {
   hashSessionToken,
   inspectUrl,
   installDuckdb,
+  isBlockingCrawlIssue,
   isDuckdbInstalled,
   isValidReleaseId,
   latestQueryBasketRevision,
@@ -246,6 +268,7 @@ import {
   listMonthlyKeywords,
   listPlaceActionLinks,
   listReviews,
+  listSitemaps,
   loadDuckdb,
   markSessionFailed,
   measurementRunCompleteness,
@@ -255,6 +278,7 @@ import {
   nextRunFromCron,
   nextRunFromSchedule,
   notProbeRun,
+  parseBingDate,
   parseCookieHeader,
   previewCompetitorAutoAliases,
   probeLatestRelease,
@@ -292,7 +316,7 @@ import {
   webhookResponseReason,
   webhookTargetRefusalReason,
   writeAuditLog
-} from "./chunk-AI75KS7G.js";
+} from "./chunk-SDXMG4VX.js";
 import {
   OperationalLogStore,
   SentimentIdempotencyConflict,
@@ -311,6 +335,13 @@ import {
   backlinkSummaries,
   bingConnections,
   bingCoverageSnapshots,
+  bingCrawlStats,
+  bingKeywordDemand,
+  bingPageStats,
+  bingQueryStats,
+  bingSiteSnapshots,
+  bingSitemaps,
+  bingTrafficDaily,
   bingUrlInspections,
   ccReleaseSyncs,
   competitors,
@@ -339,6 +370,7 @@ import {
   gscDataWatermarks,
   gscQueryDailyTotals,
   gscSearchData,
+  gscSitemaps,
   gscUrlInspections,
   gtmConnections,
   gtmRawSnapshots,
@@ -376,11 +408,12 @@ import {
   siteCrawlRunRequests,
   siteCrawlSnapshots,
   siteLivenessState,
+  sitemapListSyncs,
   trafficSources,
   unrecognizedAgentEventsHourly,
   unrecognizedAgentNotifyState,
   usageCounters
-} from "./chunk-AYYZ4HKJ.js";
+} from "./chunk-USHY3SH6.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AI_ENGINE_DOMAINS,
@@ -390,6 +423,7 @@ import {
   AgentProviderIds,
   AppError,
   BacklinkSources,
+  BingSiteSnapshotKinds,
   CHECK_RUNTIME_ERROR_SUFFIX,
   CITED_URL_CAPTURE_VERSION,
   CcReleaseSyncStatuses,
@@ -636,7 +670,7 @@ import {
   winnabilityClassLabel,
   withRetry,
   withSkippedProviders
-} from "./chunk-F643WELJ.js";
+} from "./chunk-ETIIPSWL.js";
 
 // src/google-marketing-runtime.ts
 import crypto2 from "crypto";
@@ -3320,13 +3354,13 @@ function createGoogleMarketingRuntime(options) {
 
 // src/server.ts
 import { createRequire } from "module";
-import crypto26 from "crypto";
+import crypto27 from "crypto";
 import fs5 from "fs";
 import path5 from "path";
 import { isIP as isIP2 } from "net";
 import { fileURLToPath } from "url";
 import { setImmediate as yieldToEventLoop4 } from "timers/promises";
-import { and as and28, eq as eq34, isNotNull as isNotNull5, isNull as isNull8, lte as lte3, max, ne as ne4, or as or4, sql as sql14 } from "drizzle-orm";
+import { and as and29, eq as eq35, isNotNull as isNotNull5, isNull as isNull8, lte as lte3, max, ne as ne4, or as or4, sql as sql15 } from "drizzle-orm";
 
 // src/seo-runtime.ts
 import { eq, inArray } from "drizzle-orm";
@@ -5940,7 +5974,7 @@ function nonBlank(value) {
   return trimmed ? trimmed : void 0;
 }
 function resolveBuildCommit(env = process.env) {
-  const embedded = true ? "3e6b78ab9a0ad676e2df968c5b36d5746d9639cf" : void 0;
+  const embedded = true ? "c97db3b634ae1944197825d1b93afaee2b7f41ad" : void 0;
   return nonBlank(embedded) ?? nonBlank(env.CANONRY_COMMIT);
 }
 function resolveInstanceIdentity(env = process.env) {
@@ -7916,15 +7950,15 @@ var JobRunner = class {
       const dispatchable = [];
       for (const registered of activeProviders) {
         const name = registered.adapter.name;
-        const count5 = unitsByProvider.get(name)?.length ?? 0;
+        const count6 = unitsByProvider.get(name)?.length ?? 0;
         const scope = `${projectId}:${adapterConnectionName(registered.adapter)}`;
         const limit = registered.config.quotaPolicy.maxRequestsPerDay;
-        const quota = reserveDailyQueryQuota(this.db, { scope, period: todayPeriod, count: count5, limit });
+        const quota = reserveDailyQueryQuota(this.db, { scope, period: todayPeriod, count: count6, limit });
         if (!quota.reserved) {
-          providerErrors.set(name, `Daily quota exceeded for ${name}: ${quota.used} queries used today, limit is ${limit}. This fill needs ${count5} more.`);
+          providerErrors.set(name, `Daily quota exceeded for ${name}: ${quota.used} queries used today, limit is ${limit}. This fill needs ${count6} more.`);
           continue;
         }
-        providerReservations.set(name, { scope, period: todayPeriod, reserved: count5 });
+        providerReservations.set(name, { scope, period: todayPeriod, reserved: count6 });
         dispatchable.push(registered);
       }
       const executionGates = /* @__PURE__ */ new Map();
@@ -8036,8 +8070,8 @@ var JobRunner = class {
         const remaining = /* @__PURE__ */ new Map();
         for (const slot of state.missing) remaining.set(slot.provider, (remaining.get(slot.provider) ?? 0) + 1);
         const providers = {};
-        for (const [provider, count5] of remaining) {
-          providers[provider] = fresh[provider] ?? previous[provider] ?? { message: `Expected measurements not run yet: ${count5}.` };
+        for (const [provider, count6] of remaining) {
+          providers[provider] = fresh[provider] ?? previous[provider] ?? { message: `Expected measurements not run yet: ${count6}.` };
         }
         txDb.update(runs).set({ error: serializeRunError({ providers }) }).where(and3(eq4(runs.id, input.runId), eq4(runs.status, "partial"))).run();
       }
@@ -8294,7 +8328,7 @@ var JobRunner = class {
       log2.error("run.answer-fields-rescore-failed", { runId: recording.runId, projectId, error: describeError(err) });
     }
   }
-  incrementUsage(scope, metric, count5) {
+  incrementUsage(scope, metric, count6) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const period = now.slice(0, 10);
     this.db.insert(usageCounters).values({
@@ -8302,11 +8336,11 @@ var JobRunner = class {
       scope,
       period,
       metric,
-      count: count5,
+      count: count6,
       updatedAt: now
     }).onConflictDoUpdate({
       target: [usageCounters.scope, usageCounters.period, usageCounters.metric],
-      set: { count: sql2`${usageCounters.count} + ${count5}`, updatedAt: now }
+      set: { count: sql2`${usageCounters.count} + ${count6}`, updatedAt: now }
     }).run();
   }
   flushProviderUsage(providerDispatchCounts, providerReservations) {
@@ -8589,6 +8623,64 @@ function googleRunFailure(err) {
 
 // src/gsc-sync.ts
 var log3 = createLogger("GscSync");
+var GSC_SITEMAP_INDEX_MAX_PER_SYNC = 20;
+function countOrNull(value) {
+  if (value === void 0 || value === "") return null;
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? n : null;
+}
+function gscSitemapUrlCount(sitemap) {
+  if (!sitemap.contents || sitemap.contents.length === 0) return null;
+  return sitemap.contents.reduce((sum, content) => sum + (countOrNull(content.submitted) ?? 0), 0);
+}
+async function syncGscSitemaps(db, projectId, runId, accessToken, propertyId) {
+  const top = await listSitemaps(accessToken, propertyId);
+  const indexes = top.filter((sitemap) => sitemap.isSitemapsIndex);
+  const read = indexes.slice(0, GSC_SITEMAP_INDEX_MAX_PER_SYNC);
+  const files = /* @__PURE__ */ new Map();
+  for (const index of read) files.set(index.path, await listSitemaps(accessToken, propertyId, index.path));
+  const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const toRow = (sitemap, parentUrl) => ({
+    projectId,
+    url: sitemap.path,
+    parentUrl,
+    isIndex: Boolean(sitemap.isSitemapsIndex),
+    isPending: Boolean(sitemap.isPending),
+    type: sitemap.type ?? null,
+    urlCount: gscSitemapUrlCount(sitemap),
+    warnings: countOrNull(sitemap.warnings),
+    errors: countOrNull(sitemap.errors),
+    submittedAt: sitemap.lastSubmitted ?? null,
+    lastDownloadedAt: sitemap.lastDownloaded ?? null,
+    syncRunId: runId,
+    syncedAt
+  });
+  const rows = [
+    ...top.map((sitemap) => toRow(sitemap, null)),
+    ...[...files.entries()].flatMap(([parent, children]) => children.map((child) => toRow({ ...child, isSitemapsIndex: false }, parent)))
+  ];
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const row of rows) if (!byUrl.has(row.url)) byUrl.set(row.url, row);
+  const unread = new Set(indexes.slice(GSC_SITEMAP_INDEX_MAX_PER_SYNC).map((index) => index.path));
+  db.transaction((tx) => {
+    const stored = tx.select({ url: gscSitemaps.url, parentUrl: gscSitemaps.parentUrl }).from(gscSitemaps).where(eq7(gscSitemaps.projectId, projectId)).all();
+    for (const row of stored) {
+      if (byUrl.has(row.url) || row.parentUrl !== null && unread.has(row.parentUrl)) continue;
+      tx.delete(gscSitemaps).where(and5(eq7(gscSitemaps.projectId, projectId), eq7(gscSitemaps.url, row.url))).run();
+    }
+    for (const row of byUrl.values()) {
+      tx.insert(gscSitemaps).values({ id: crypto8.randomUUID(), ...row }).onConflictDoUpdate({
+        target: [gscSitemaps.projectId, gscSitemaps.url],
+        set: { ...row }
+      }).run();
+    }
+    tx.insert(sitemapListSyncs).values({ projectId, engine: "google", syncedAt, syncRunId: runId }).onConflictDoUpdate({
+      target: [sitemapListSyncs.projectId, sitemapListSyncs.engine],
+      set: { syncedAt, syncRunId: runId }
+    }).run();
+  });
+  return { sitemaps: byUrl.size, indexesRead: read.length };
+}
 async function executeGscSync(db, runId, projectId, opts) {
   const reportOutcome = startRunOutcome(db, runId, FeatureNames.search_console, "sync");
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -8744,6 +8836,12 @@ async function executeGscSync(db, runId, projectId, opts) {
       }).run();
     }
     log3.info("query-totals.complete", { runId, projectId, rowCount: queryTotalRows.length });
+    try {
+      const stored = await syncGscSitemaps(db, projectId, runId, accessToken, propertyId);
+      log3.info("sitemaps.complete", { runId, projectId, ...stored });
+    } catch (err) {
+      log3.warn("sitemaps.failed", { runId, projectId, error: describeError(err) });
+    }
     const coverage = writeCoverageSnapshot(db, projectId, runId);
     db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq7(runs.id, runId)).run();
     log3.info("sync.completed", { runId, projectId, searchDataRows: rows.length, indexed: coverage.indexed, notIndexed: coverage.notIndexed, unknown: coverage.unknown, verifiedByInspection: coverage.verifiedByInspection });
@@ -10595,20 +10693,6 @@ function bingRunFailure(err) {
   return runFailure(err, err instanceof BingApiError && err.isThrottle ? OutcomeReasonCodes.RATE_LIMITED : void 0);
 }
 var BING_INSPECT_SPACING_MS = 2e3;
-function parseBingDate(value) {
-  if (!value) return null;
-  const match = /\/Date\((-?\d+)(?:[-+]\d+)?\)\//.exec(value);
-  if (!match) return null;
-  const ms = parseInt(match[1], 10);
-  if (ms <= 0) return null;
-  return new Date(ms).toISOString();
-}
-function isBlockingIssueType(issueType) {
-  if (!issueType) return true;
-  const trimmed = issueType.trim();
-  if (!trimmed) return true;
-  return trimmed.split(/\s+/).some((flag) => !/^(?:None|Seo(?:Issues|Concerns))$/i.test(flag));
-}
 async function executeBingInspectSitemap(db, runId, projectId, opts) {
   const reportOutcome = startRunOutcome(db, runId, FeatureNames.bing, "sync");
   let abortCause;
@@ -10653,7 +10737,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     try {
       const issues = await getCrawlIssues(conn.apiKey, conn.siteUrl);
       for (const issue of issues) {
-        if (issue.Url && isBlockingIssueType(issue.IssueType ?? null)) {
+        if (issue.Url && isBlockingCrawlIssue(issue.IssueType ?? null)) {
           blockedUrls.add(issue.Url);
         }
       }
@@ -10846,10 +10930,428 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
   }
 }
 
-// src/coverage-refresh.ts
+// src/bing-sync.ts
 import crypto15 from "crypto";
-import { and as and9, desc as desc6, eq as eq13, inArray as inArray6 } from "drizzle-orm";
-var log10 = createLogger("CoverageRefresh");
+import { and as and9, eq as eq13, notInArray as notInArray2, sql as sql5 } from "drizzle-orm";
+var log10 = createLogger("BingSync");
+var BING_SYNC_SPACING_MS = 2e3;
+var BING_KEYWORD_DEMAND_REFRESH_DAYS = 7;
+var BING_KEYWORD_DEMAND_MAX_PER_SYNC = 30;
+var BING_SITEMAP_INDEX_MAX_PER_SYNC = 20;
+var BING_NOT_AUTHORIZED = 14;
+var BingSyncThrottled = class extends Error {
+  constructor(cause) {
+    super(describeError(cause), { cause });
+    this.name = "BingSyncThrottled";
+  }
+};
+function isThrottle(err) {
+  return err instanceof BingApiError && (err.isThrottle || err.status === 429);
+}
+function count3(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+}
+var BLOCKED_ENTITY_TYPES = ["page", "directory"];
+var BLOCKED_REQUEST_TYPES = ["cache-only", "full-removal"];
+var COUNTRY_REGION_TYPES = ["page", "directory", "domain", "subdomain"];
+var SITE_ROLES = ["administrator", "read-only", "read-write"];
+function enumWord(words, value) {
+  return typeof value === "number" && Number.isInteger(value) ? words[value] ?? null : null;
+}
+function convertDates(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "__type") continue;
+    out[key] = typeof value === "string" && value.startsWith("/Date(") ? parseBingDate(value) : value;
+  }
+  return out;
+}
+function mergeWeekly(rows) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const date = bingDateToDay(row.Date);
+    const key = typeof row.Query === "string" ? row.Query.trim() : "";
+    if (!date || !key) continue;
+    const id = `${date}\0${key}`;
+    const entry = merged.get(id) ?? { date, key, clicks: 0, impressions: 0, clickPosWeight: 0, clickPosSum: 0, imprPosWeight: 0, imprPosSum: 0 };
+    const clicks = count3(row.Clicks);
+    const impressions = count3(row.Impressions);
+    entry.clicks += clicks;
+    entry.impressions += impressions;
+    const clickPos = bingPositionOrNull(row.AvgClickPosition);
+    if (clickPos !== null) {
+      const weight = Math.max(clicks, 1);
+      entry.clickPosSum += clickPos * weight;
+      entry.clickPosWeight += weight;
+    }
+    const imprPos = bingPositionOrNull(row.AvgImpressionPosition);
+    if (imprPos !== null) {
+      const weight = Math.max(impressions, 1);
+      entry.imprPosSum += imprPos * weight;
+      entry.imprPosWeight += weight;
+    }
+    merged.set(id, entry);
+  }
+  return [...merged.values()].map((entry) => ({
+    date: entry.date,
+    key: entry.key,
+    clicks: entry.clicks,
+    impressions: entry.impressions,
+    avgClickPosition: entry.clickPosWeight > 0 ? entry.clickPosSum / entry.clickPosWeight : null,
+    avgImpressionPosition: entry.imprPosWeight > 0 ? entry.imprPosSum / entry.imprPosWeight : null
+  }));
+}
+async function executeBingSync(db, runId, projectId, opts) {
+  const reportOutcome = startRunOutcome(db, runId, FeatureNames.bing, "sync");
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const sleep3 = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  db.update(runs).set({ status: RunStatuses.running, startedAt: now().toISOString() }).where(eq13(runs.id, runId)).run();
+  try {
+    const project = db.select().from(projects).where(eq13(projects.id, projectId)).get();
+    if (!project) {
+      throw withOutcomeReason(new Error(`Project not found: ${projectId}`), OutcomeReasonCodes.NOT_FOUND);
+    }
+    const conn = opts.config.bing?.connections?.find((c) => c.domain === project.canonicalDomain);
+    if (!conn) {
+      throw withOutcomeReason(
+        new Error('No Bing connection found for this project. Run "canonry bing connect <project>" first.'),
+        OutcomeReasonCodes.NOT_CONNECTED
+      );
+    }
+    if (!conn.siteUrl) {
+      throw withOutcomeReason(
+        new Error('No Bing site configured. Run "canonry bing set-site <project> <url>" first.'),
+        OutcomeReasonCodes.PROPERTY_NOT_FOUND
+      );
+    }
+    const apiKey = conn.apiKey;
+    const siteUrl = conn.siteUrl;
+    const gate = sharedRateGate(credentialGateKey("bing", apiKey));
+    let throttled = false;
+    async function call(read) {
+      if (throttled) throw new BingSyncThrottled(new Error("Bing throttled this account earlier in the run"));
+      await gate.take(BING_SYNC_SPACING_MS, sleep3);
+      try {
+        return await read();
+      } catch (err) {
+        if (isThrottle(err)) {
+          throttled = true;
+          throw new BingSyncThrottled(err);
+        }
+        throw err;
+      }
+    }
+    const results = [];
+    async function section(name, work) {
+      try {
+        const rows2 = await work();
+        results.push({ section: name, ok: true, rows: rows2 });
+        log10.info("section.completed", { runId, projectId, section: name, rows: rows2 });
+      } catch (err) {
+        const error2 = describeError(err);
+        results.push({ section: name, ok: false, rows: 0, error: error2 });
+        log10.warn("section.failed", { runId, projectId, section: name, error: error2, throttled: err instanceof BingSyncThrottled });
+      }
+    }
+    await section("traffic", async () => {
+      const rows2 = await call(() => getRankAndTrafficStats(apiKey, siteUrl));
+      const syncedAt = now().toISOString();
+      let written = 0;
+      db.transaction((tx) => {
+        for (const row of rows2) {
+          const date = bingDateToDay(row.Date);
+          if (!date) continue;
+          const values = { clicks: count3(row.Clicks), impressions: count3(row.Impressions), syncRunId: runId, syncedAt };
+          tx.insert(bingTrafficDaily).values({ id: crypto15.randomUUID(), projectId, date, ...values }).onConflictDoUpdate({ target: [bingTrafficDaily.projectId, bingTrafficDaily.date], set: values }).run();
+          written += 1;
+        }
+      });
+      return written;
+    });
+    await section("queries", async () => {
+      const merged = mergeWeekly(await call(() => getQueryStats(apiKey, siteUrl)));
+      const syncedAt = now().toISOString();
+      db.transaction((tx) => {
+        for (const row of merged) {
+          const values = { clicks: row.clicks, impressions: row.impressions, avgClickPosition: row.avgClickPosition, avgImpressionPosition: row.avgImpressionPosition, syncRunId: runId, syncedAt };
+          tx.insert(bingQueryStats).values({ id: crypto15.randomUUID(), projectId, date: row.date, query: row.key, ...values }).onConflictDoUpdate({ target: [bingQueryStats.projectId, bingQueryStats.date, bingQueryStats.query], set: values }).run();
+        }
+      });
+      return merged.length;
+    });
+    await section("pages", async () => {
+      const merged = mergeWeekly(await call(() => getPageStats(apiKey, siteUrl)));
+      const syncedAt = now().toISOString();
+      db.transaction((tx) => {
+        for (const row of merged) {
+          const values = { clicks: row.clicks, impressions: row.impressions, avgClickPosition: row.avgClickPosition, avgImpressionPosition: row.avgImpressionPosition, syncRunId: runId, syncedAt };
+          tx.insert(bingPageStats).values({ id: crypto15.randomUUID(), projectId, date: row.date, page: row.key, ...values }).onConflictDoUpdate({ target: [bingPageStats.projectId, bingPageStats.date, bingPageStats.page], set: values }).run();
+        }
+      });
+      return merged.length;
+    });
+    await section("crawl-stats", async () => {
+      const rows2 = await call(() => getCrawlStats(apiKey, siteUrl));
+      const syncedAt = now().toISOString();
+      let written = 0;
+      db.transaction((tx) => {
+        for (const row of rows2) {
+          const date = bingDateToDay(row.Date);
+          if (!date) continue;
+          const values = {
+            crawledPages: count3(row.CrawledPages),
+            inIndex: count3(row.InIndex),
+            crawlErrors: count3(row.CrawlErrors),
+            inLinks: count3(row.InLinks),
+            code2xx: count3(row.Code2xx),
+            code301: count3(row.Code301),
+            code302: count3(row.Code302),
+            code4xx: count3(row.Code4xx),
+            code5xx: count3(row.Code5xx),
+            allOtherCodes: count3(row.AllOtherCodes),
+            blockedByRobotsTxt: count3(row.BlockedByRobotsTxt),
+            connectionTimeout: count3(row.ConnectionTimeout),
+            containsMalware: count3(row.ContainsMalware),
+            dnsFailures: count3(row.DnsFailures),
+            syncRunId: runId,
+            syncedAt
+          };
+          tx.insert(bingCrawlStats).values({ id: crypto15.randomUUID(), projectId, date, ...values }).onConflictDoUpdate({ target: [bingCrawlStats.projectId, bingCrawlStats.date], set: values }).run();
+          written += 1;
+        }
+      });
+      return written;
+    });
+    await section("sitemaps", async () => {
+      const top = await call(() => getFeeds(apiKey, siteUrl));
+      const collected = /* @__PURE__ */ new Map();
+      for (const feed of top) {
+        if (feed.Url) collected.set(feed.Url, { feed, parentUrl: null });
+      }
+      const indexes = top.filter((feed) => /index/i.test(feed.Type ?? "")).slice(0, BING_SITEMAP_INDEX_MAX_PER_SYNC);
+      for (const index of indexes) {
+        const details = await call(() => getFeedDetails(apiKey, siteUrl, index.Url));
+        for (const child of details) {
+          if (!child.Url || child.Url === index.Url || collected.has(child.Url)) continue;
+          collected.set(child.Url, { feed: child, parentUrl: index.Url });
+        }
+      }
+      const syncedAt = now().toISOString();
+      const urls = [...collected.keys()];
+      db.transaction((tx) => {
+        for (const { feed, parentUrl } of collected.values()) {
+          const values = {
+            parentUrl,
+            type: feed.Type ?? "Unknown",
+            status: feed.Status ?? "Unknown",
+            urlCount: count3(feed.UrlCount),
+            fileSize: count3(feed.FileSize),
+            compressed: feed.Compressed === true,
+            submittedAt: parseBingDate(feed.Submitted ?? null),
+            lastCrawledAt: parseBingDate(feed.LastCrawled ?? null),
+            syncRunId: runId,
+            syncedAt
+          };
+          tx.insert(bingSitemaps).values({ id: crypto15.randomUUID(), projectId, url: feed.Url, ...values }).onConflictDoUpdate({ target: [bingSitemaps.projectId, bingSitemaps.url], set: values }).run();
+        }
+        tx.delete(bingSitemaps).where(urls.length > 0 ? and9(eq13(bingSitemaps.projectId, projectId), notInArray2(bingSitemaps.url, urls)) : eq13(bingSitemaps.projectId, projectId)).run();
+        tx.insert(sitemapListSyncs).values({ projectId, engine: "bing", syncedAt, syncRunId: runId }).onConflictDoUpdate({ target: [sitemapListSyncs.projectId, sitemapListSyncs.engine], set: { syncedAt, syncRunId: runId } }).run();
+      });
+      return collected.size;
+    });
+    await section("site", async () => {
+      const reads = [
+        {
+          kind: BingSiteSnapshotKinds["url-submission-quota"],
+          read: async () => {
+            const quota = await getUrlSubmissionQuota(apiKey, siteUrl);
+            return { dailyQuota: count3(quota?.DailyQuota), monthlyQuota: count3(quota?.MonthlyQuota) };
+          }
+        },
+        {
+          kind: BingSiteSnapshotKinds["content-submission-quota"],
+          read: async () => {
+            const quota = await getContentSubmissionQuota(apiKey, siteUrl);
+            return { dailyQuota: count3(quota?.DailyQuota), monthlyQuota: count3(quota?.MonthlyQuota) };
+          }
+        },
+        {
+          kind: BingSiteSnapshotKinds["crawl-settings"],
+          read: async () => {
+            const settings = await getCrawlSettings(apiKey, siteUrl);
+            return {
+              crawlBoostAvailable: settings?.CrawlBoostAvailable === true,
+              crawlBoostEnabled: settings?.CrawlBoostEnabled === true,
+              crawlRate: Array.isArray(settings?.CrawlRate) ? settings.CrawlRate.filter((v) => typeof v === "number") : []
+            };
+          }
+        },
+        {
+          kind: BingSiteSnapshotKinds["crawl-issues"],
+          read: async () => (await getCrawlIssues(apiKey, siteUrl)).map((issue) => ({
+            url: issue.Url,
+            httpCode: typeof issue.HttpCode === "number" ? issue.HttpCode : null,
+            inLinks: typeof issue.InLinks === "number" ? issue.InLinks : null,
+            issues: issue.Issues ?? issue.IssueType ?? null
+          }))
+        },
+        {
+          kind: BingSiteSnapshotKinds["blocked-urls"],
+          read: async () => (await getBlockedUrls(apiKey, siteUrl)).map((row) => ({
+            url: row.Url,
+            date: parseBingDate(row.Date ?? null),
+            daysToExpire: typeof row.DaysToExpire === "number" ? row.DaysToExpire : null,
+            entityType: enumWord(BLOCKED_ENTITY_TYPES, row.EntityType),
+            requestType: enumWord(BLOCKED_REQUEST_TYPES, row.RequestType)
+          }))
+        },
+        {
+          kind: BingSiteSnapshotKinds["page-preview-blocks"],
+          read: async () => (await getActivePagePreviewBlocks(apiKey, siteUrl)).map(convertDates)
+        },
+        {
+          kind: BingSiteSnapshotKinds["deep-link-blocks"],
+          read: async () => (await getDeepLinkBlocks(apiKey, siteUrl)).map(convertDates)
+        },
+        {
+          kind: BingSiteSnapshotKinds["query-parameters"],
+          read: async () => (await getQueryParameters(apiKey, siteUrl)).map((row) => ({
+            parameter: row.Parameter,
+            isEnabled: typeof row.IsEnabled === "boolean" ? row.IsEnabled : null,
+            date: parseBingDate(row.Date ?? null),
+            source: row.Source ?? null
+          }))
+        },
+        {
+          kind: BingSiteSnapshotKinds["country-region-settings"],
+          read: async () => (await getCountryRegionSettings(apiKey, siteUrl)).map((row) => ({
+            url: row.Url,
+            countryCode: row.TwoLetterIsoCountryCode,
+            type: enumWord(COUNTRY_REGION_TYPES, row.Type),
+            date: parseBingDate(row.Date ?? null)
+          }))
+        },
+        {
+          kind: BingSiteSnapshotKinds["fetched-urls"],
+          read: async () => (await getFetchedUrls(apiKey, siteUrl)).map((row) => ({
+            url: row.Url,
+            date: parseBingDate(row.Date ?? null),
+            expired: typeof row.Expired === "boolean" ? row.Expired : null,
+            fetched: typeof row.Fetched === "boolean" ? row.Fetched : null
+          }))
+        },
+        {
+          kind: BingSiteSnapshotKinds["connected-pages"],
+          read: async () => (await getConnectedPages(apiKey, siteUrl)).map(convertDates)
+        },
+        {
+          kind: BingSiteSnapshotKinds["site-roles"],
+          read: async () => (await getSiteRoles(apiKey, siteUrl)).map((row) => ({
+            site: row.Site ?? null,
+            email: row.Email ?? null,
+            role: enumWord(SITE_ROLES, row.Role),
+            date: parseBingDate(row.Date ?? null),
+            expired: typeof row.Expired === "boolean" ? row.Expired : null
+          }))
+        }
+      ];
+      let failed2 = 0;
+      let stored = 0;
+      for (const { kind, read } of reads) {
+        let status2 = "ok";
+        let payload = null;
+        let error2 = null;
+        try {
+          payload = await call(read);
+        } catch (err) {
+          if (err instanceof BingSyncThrottled) throw err;
+          const unauthorized = err instanceof BingApiError && err.bingErrorCode === BING_NOT_AUTHORIZED;
+          status2 = unauthorized ? "unauthorized" : "failed";
+          error2 = unauthorized ? "This Bing key is not allowed to read this setting (owner-only)." : describeError(err);
+          if (!unauthorized) failed2 += 1;
+        }
+        const syncedAt = now().toISOString();
+        const previous = status2 === "failed" ? db.select({ payload: bingSiteSnapshots.payload }).from(bingSiteSnapshots).where(and9(eq13(bingSiteSnapshots.projectId, projectId), eq13(bingSiteSnapshots.kind, kind))).get() : void 0;
+        const values = { status: status2, payload: status2 === "failed" ? previous?.payload ?? null : payload, error: error2, syncRunId: runId, syncedAt };
+        db.insert(bingSiteSnapshots).values({ id: crypto15.randomUUID(), projectId, kind, ...values }).onConflictDoUpdate({ target: [bingSiteSnapshots.projectId, bingSiteSnapshots.kind], set: values }).run();
+        stored += 1;
+      }
+      if (failed2 > 0) throw new Error(`${failed2} of ${reads.length} Bing site settings could not be read`);
+      return stored;
+    });
+    await section("keyword-demand", async () => {
+      const market = bingKeywordMarket(project.country, project.language);
+      const tracked = db.select({ query: queries.query }).from(queries).where(eq13(queries.projectId, projectId)).all();
+      if (tracked.length === 0) return 0;
+      const cutoff = new Date(now().getTime() - BING_KEYWORD_DEMAND_REFRESH_DAYS * 864e5).toISOString();
+      const lastSynced = new Map(db.select({ query: bingKeywordDemand.query, syncedAt: sql5`MAX(${bingKeywordDemand.syncedAt})` }).from(bingKeywordDemand).where(and9(
+        eq13(bingKeywordDemand.projectId, projectId),
+        eq13(bingKeywordDemand.country, market.country),
+        eq13(bingKeywordDemand.language, market.language)
+      )).groupBy(bingKeywordDemand.query).all().map((row) => [row.query, row.syncedAt]));
+      const due = tracked.map((row) => ({ query: row.query, syncedAt: lastSynced.get(row.query) ?? null })).filter((row) => row.syncedAt === null || row.syncedAt < cutoff).sort((a, b) => (a.syncedAt ?? "").localeCompare(b.syncedAt ?? "")).slice(0, BING_KEYWORD_DEMAND_MAX_PER_SYNC);
+      let written = 0;
+      let failures = 0;
+      let lastError;
+      for (const { query } of due) {
+        let history;
+        try {
+          history = await call(() => getKeywordHistory(apiKey, query, market));
+        } catch (err) {
+          if (err instanceof BingSyncThrottled) throw err;
+          failures += 1;
+          lastError = err;
+          continue;
+        }
+        const syncedAt = now().toISOString();
+        db.transaction((tx) => {
+          for (const week of history) {
+            const date = bingDateToDay(week.Date);
+            if (!date) continue;
+            const values = { impressions: count3(week.Impressions), broadImpressions: count3(week.BroadImpressions), syncRunId: runId, syncedAt };
+            tx.insert(bingKeywordDemand).values({ id: crypto15.randomUUID(), projectId, query, country: market.country, language: market.language, date, ...values }).onConflictDoUpdate({
+              target: [bingKeywordDemand.projectId, bingKeywordDemand.query, bingKeywordDemand.country, bingKeywordDemand.language, bingKeywordDemand.date],
+              set: values
+            }).run();
+            written += 1;
+          }
+          if (history.length === 0) {
+            const date = now().toISOString().slice(0, 10);
+            tx.insert(bingKeywordDemand).values({ id: crypto15.randomUUID(), projectId, query, country: market.country, language: market.language, date, impressions: 0, broadImpressions: 0, syncRunId: runId, syncedAt }).onConflictDoNothing().run();
+          }
+        });
+      }
+      if (failures > 0) throw new Error(`${failures} of ${due.length} keyword demand reads failed; last: ${describeError(lastError)}`);
+      return written;
+    });
+    const failed = results.filter((r) => !r.ok);
+    const status = failed.length === 0 ? RunStatuses.completed : failed.length === results.length ? RunStatuses.failed : RunStatuses.partial;
+    const error = failed.length === 0 ? null : `${throttled ? "Bing throttled this account; stopped early. " : ""}${failed.map((r) => `${r.section}: ${r.error}`).join("; ")}`.slice(0, 2e3);
+    db.update(runs).set({ status, error, finishedAt: now().toISOString() }).where(eq13(runs.id, runId)).run();
+    const rows = results.reduce((sum, r) => sum + r.rows, 0);
+    log10.info("sync.completed", { runId, projectId, status, rows, failedSections: failed.map((r) => r.section) });
+    if (status === RunStatuses.completed) {
+      reportOutcome({ status: OutcomeStatuses.succeeded, counts: { rows, items: results.length } });
+    } else {
+      reportOutcome({
+        status: status === RunStatuses.partial ? OutcomeStatuses.partial : OutcomeStatuses.failed,
+        ...runFailure(new Error(error ?? "Bing sync failed"), throttled ? OutcomeReasonCodes.RATE_LIMITED : void 0),
+        counts: { rows, items: results.length, failures: failed.length }
+      });
+    }
+  } catch (err) {
+    const message = describeError(err);
+    db.update(runs).set({ status: RunStatuses.failed, error: message, finishedAt: now().toISOString() }).where(eq13(runs.id, runId)).run();
+    log10.error("sync.failed", { runId, projectId, error: message });
+    reportOutcome({ status: OutcomeStatuses.failed, ...runFailure(err) });
+    throw err;
+  }
+}
+
+// src/coverage-refresh.ts
+import crypto16 from "crypto";
+import { and as and10, desc as desc6, eq as eq14, inArray as inArray6 } from "drizzle-orm";
+var log11 = createLogger("CoverageRefresh");
 var COVERAGE_REFRESH_MIN_INTERVAL_MS = 60 * 60 * 1e3;
 var COVERAGE_REFRESH_MANUAL_MIN_INTERVAL_MS = 2 * 60 * 1e3;
 var ACTIVE_OR_DONE_STATUSES = [
@@ -10860,44 +11362,44 @@ var ACTIVE_OR_DONE_STATUSES = [
 ];
 var IN_FLIGHT_STATUSES = [RunStatuses.queued, RunStatuses.running];
 function runWasUserInitiated(db, runId) {
-  const row = db.select({ trigger: runs.trigger }).from(runs).where(eq13(runs.id, runId)).get();
+  const row = db.select({ trigger: runs.trigger }).from(runs).where(eq14(runs.id, runId)).get();
   return row?.trigger === RunTriggers.manual;
 }
 var defaultDeps = { executeInspectSitemap };
 async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps, nowMs = Date.now(), opts = {}) {
-  const project = db.select({ canonicalDomain: projects.canonicalDomain }).from(projects).where(eq13(projects.id, projectId)).get();
+  const project = db.select({ canonicalDomain: projects.canonicalDomain }).from(projects).where(eq14(projects.id, projectId)).get();
   if (!project) return null;
   const { clientId, clientSecret } = getGoogleAuthConfig(config);
   if (!clientId || !clientSecret) return null;
   const conn = getGoogleConnection(config, project.canonicalDomain, "gsc");
   if (!conn?.refreshToken || !conn.propertyId) return null;
   const inFlight = db.select({ createdAt: runs.createdAt }).from(runs).where(
-    and9(
-      eq13(runs.projectId, projectId),
-      eq13(runs.kind, RunKinds["inspect-sitemap"]),
+    and10(
+      eq14(runs.projectId, projectId),
+      eq14(runs.kind, RunKinds["inspect-sitemap"]),
       inArray6(runs.status, IN_FLIGHT_STATUSES)
     )
   ).orderBy(desc6(runs.createdAt)).limit(1).get();
   if (inFlight) {
-    log10.info("skip.in-flight", { projectId });
+    log11.info("skip.in-flight", { projectId });
     return null;
   }
   const windowMs = opts.userInitiated ? COVERAGE_REFRESH_MANUAL_MIN_INTERVAL_MS : COVERAGE_REFRESH_MIN_INTERVAL_MS;
   const recent = db.select({ createdAt: runs.createdAt }).from(runs).where(
-    and9(
-      eq13(runs.projectId, projectId),
-      eq13(runs.kind, RunKinds["inspect-sitemap"]),
+    and10(
+      eq14(runs.projectId, projectId),
+      eq14(runs.kind, RunKinds["inspect-sitemap"]),
       inArray6(runs.status, ACTIVE_OR_DONE_STATUSES)
     )
   ).orderBy(desc6(runs.createdAt)).limit(1).get();
   if (recent) {
     const ageMs = nowMs - Date.parse(recent.createdAt);
     if (Number.isFinite(ageMs) && ageMs < windowMs) {
-      log10.info("skip.recent", { projectId, ageMs, windowMs, userInitiated: opts.userInitiated === true });
+      log11.info("skip.recent", { projectId, ageMs, windowMs, userInitiated: opts.userInitiated === true });
       return null;
     }
   }
-  const runId = crypto15.randomUUID();
+  const runId = crypto16.randomUUID();
   db.insert(runs).values({
     id: runId,
     projectId,
@@ -10906,11 +11408,11 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
     trigger: RunTriggers.scheduled,
     createdAt: new Date(nowMs).toISOString()
   }).run();
-  log10.info("refresh.start", { projectId, runId });
+  log11.info("refresh.start", { projectId, runId });
   try {
     await deps.executeInspectSitemap(db, runId, projectId, { config });
   } catch (err) {
-    log10.error("refresh.failed", {
+    log11.error("refresh.failed", {
       projectId,
       runId,
       error: describeError(err)
@@ -10920,10 +11422,10 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
 }
 
 // src/commoncrawl-sync.ts
-import crypto16 from "crypto";
+import crypto17 from "crypto";
 import path4 from "path";
-import { and as and10, eq as eq14, sql as sql5 } from "drizzle-orm";
-var log11 = createLogger("CommonCrawlSync");
+import { and as and11, eq as eq15, sql as sql6 } from "drizzle-orm";
+var log12 = createLogger("CommonCrawlSync");
 var INSERT_CHUNK_SIZE = 1e4;
 function defaultDeps2() {
   return {
@@ -10957,7 +11459,7 @@ async function executeReleaseSync(db, syncId, opts) {
       phaseDetail: "downloading vertices + edges",
       updatedAt: downloadStartedAt,
       error: null
-    }).where(eq14(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq15(ccReleaseSyncs.id, syncId)).run();
     const paths = ccReleasePaths(release);
     const releaseCacheDir = path4.join(deps.cacheDir, release);
     const vertexPath = path4.join(releaseCacheDir, paths.vertexFilename);
@@ -10980,7 +11482,7 @@ async function executeReleaseSync(db, syncId, opts) {
       vertexSha256: vertex.sha256,
       edgesSha256: edges.sha256,
       updatedAt: downloadFinishedAt
-    }).where(eq14(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq15(ccReleaseSyncs.id, syncId)).run();
     const allProjects = db.select().from(projects).all();
     const targets = Array.from(new Set(allProjects.map((p) => p.canonicalDomain)));
     let rows = [];
@@ -10996,15 +11498,15 @@ async function executeReleaseSync(db, syncId, opts) {
     }
     const queriedAt = deps.now().toISOString();
     db.transaction((tx) => {
-      tx.delete(backlinkDomains).where(eq14(backlinkDomains.releaseSyncId, syncId)).run();
-      tx.delete(backlinkSummaries).where(eq14(backlinkSummaries.releaseSyncId, syncId)).run();
+      tx.delete(backlinkDomains).where(eq15(backlinkDomains.releaseSyncId, syncId)).run();
+      tx.delete(backlinkSummaries).where(eq15(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: crypto16.randomUUID(),
+            id: crypto17.randomUUID(),
             projectId,
             releaseSyncId: syncId,
             release,
@@ -11024,7 +11526,7 @@ async function executeReleaseSync(db, syncId, opts) {
         const projectRows = rowsByProject.get(p.id) ?? [];
         const summary = computeBacklinkSummaryMetrics(projectRows);
         tx.insert(backlinkSummaries).values({
-          id: crypto16.randomUUID(),
+          id: crypto17.randomUUID(),
           projectId: p.id,
           releaseSyncId: syncId,
           source: BacklinkSources.commoncrawl,
@@ -11057,8 +11559,8 @@ async function executeReleaseSync(db, syncId, opts) {
       domainsDiscovered: rows.length,
       updatedAt: finishedAt,
       error: null
-    }).where(eq14(ccReleaseSyncs.id, syncId)).run();
-    log11.info("sync.completed", {
+    }).where(eq15(ccReleaseSyncs.id, syncId)).run();
+    log12.info("sync.completed", {
       syncId,
       release,
       projectsProcessed: allProjects.length,
@@ -11076,7 +11578,7 @@ async function executeReleaseSync(db, syncId, opts) {
         try {
           deps.enqueueAutoExtract({ projectId: p.id, release });
         } catch (err) {
-          log11.error("auto-extract.enqueue-failed", {
+          log12.error("auto-extract.enqueue-failed", {
             syncId,
             release,
             projectId: p.id,
@@ -11093,8 +11595,8 @@ async function executeReleaseSync(db, syncId, opts) {
       error: errorMsg,
       phaseDetail: null,
       updatedAt: finishedAt
-    }).where(eq14(ccReleaseSyncs.id, syncId)).run();
-    log11.error("sync.failed", { syncId, release, error: errorMsg });
+    }).where(eq15(ccReleaseSyncs.id, syncId)).run();
+    log12.error("sync.failed", { syncId, release, error: errorMsg });
     trackFeatureCompleted({
       ...outcome,
       status: OutcomeStatuses.failed,
@@ -11126,7 +11628,7 @@ async function syncLatestReleaseOnSchedule(projectName, deps) {
     if (probed === null) report({ status: OutcomeStatuses.failed, reasonCode: OutcomeReasonCodes.NOT_FOUND });
     return;
   }
-  const alreadySynced = deps.db.select().from(ccReleaseSyncs).where(and10(eq14(ccReleaseSyncs.release, probed.release), eq14(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready))).limit(1).get();
+  const alreadySynced = deps.db.select().from(ccReleaseSyncs).where(and11(eq15(ccReleaseSyncs.release, probed.release), eq15(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready))).limit(1).get();
   if (alreadySynced) {
     deps.log.info({ projectName, release: probed.release }, "Scheduled backlinks sync: already up to date, skipping");
     report({ status: OutcomeStatuses.skipped, reasonCode: OutcomeReasonCodes.NOT_DUE });
@@ -11157,10 +11659,10 @@ function groupByProject(rows, projectsByDomain) {
 }
 
 // src/backlink-extract.ts
-import crypto17 from "crypto";
+import crypto18 from "crypto";
 import fs4 from "fs";
-import { and as and11, desc as desc7, eq as eq15 } from "drizzle-orm";
-var log12 = createLogger("BacklinkExtract");
+import { and as and12, desc as desc7, eq as eq16 } from "drizzle-orm";
+var log13 = createLogger("BacklinkExtract");
 function defaultDeps3() {
   return {
     queryBacklinks,
@@ -11173,14 +11675,14 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
   const startedAt = deps.now().toISOString();
   const reportOutcome = startRunOutcome(db, runId, "backlinks", "extract");
   let refusal;
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq15(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq16(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq15(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq16(projects.id, projectId)).get();
     if (!project) {
       refusal = OutcomeReasonCodes.NOT_FOUND;
       throw new Error(`Project not found: ${projectId}`);
     }
-    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq15(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq15(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc7(ccReleaseSyncs.createdAt)).limit(1).get();
+    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq16(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq16(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc7(ccReleaseSyncs.createdAt)).limit(1).get();
     refusal = OutcomeReasonCodes.NO_DATA;
     if (!sync) {
       throw new Error("No ready release sync available \u2014 run `canonry backlinks sync` first");
@@ -11210,15 +11712,15 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     const targetDomain = project.canonicalDomain;
     db.transaction((tx) => {
       tx.delete(backlinkDomains).where(
-        and11(
-          eq15(backlinkDomains.projectId, projectId),
-          eq15(backlinkDomains.source, BacklinkSources.commoncrawl),
-          eq15(backlinkDomains.release, release)
+        and12(
+          eq16(backlinkDomains.projectId, projectId),
+          eq16(backlinkDomains.source, BacklinkSources.commoncrawl),
+          eq16(backlinkDomains.release, release)
         )
       ).run();
       if (rows.length > 0) {
         const values = rows.map((r) => ({
-          id: crypto17.randomUUID(),
+          id: crypto18.randomUUID(),
           projectId,
           releaseSyncId: syncId,
           source: BacklinkSources.commoncrawl,
@@ -11232,7 +11734,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }
       const summary2 = computeSummary(rows);
       tx.insert(backlinkSummaries).values({
-        id: crypto17.randomUUID(),
+        id: crypto18.randomUUID(),
         projectId,
         releaseSyncId: syncId,
         source: BacklinkSources.commoncrawl,
@@ -11256,8 +11758,8 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }).run();
     });
     const finishedAt = deps.now().toISOString();
-    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq15(runs.id, runId)).run();
-    log12.info("extract.completed", { runId, projectId, release, rows: rows.length });
+    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq16(runs.id, runId)).run();
+    log13.info("extract.completed", { runId, projectId, release, rows: rows.length });
     const summary = computeSummary(rows);
     reportOutcome({ status: OutcomeStatuses.succeeded, counts: { domains: summary.totalLinkingDomains, links: summary.totalHosts } });
   } catch (err) {
@@ -11267,8 +11769,8 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       status: RunStatuses.failed,
       error: errorMsg,
       finishedAt
-    }).where(eq15(runs.id, runId)).run();
-    log12.error("extract.failed", { runId, projectId, error: errorMsg });
+    }).where(eq16(runs.id, runId)).run();
+    log13.error("extract.failed", { runId, projectId, error: errorMsg });
     reportOutcome({ status: OutcomeStatuses.failed, ...outcomeFailure(err, refusal) });
     throw err;
   }
@@ -11278,9 +11780,9 @@ function computeSummary(rows) {
 }
 
 // src/discovery-run.ts
-import crypto18 from "crypto";
-import { and as and12, eq as eq16 } from "drizzle-orm";
-var log13 = createLogger("DiscoveryRun");
+import crypto19 from "crypto";
+import { and as and13, eq as eq17 } from "drizzle-orm";
+var log14 = createLogger("DiscoveryRun");
 var DEFAULT_SEED_COUNT = 30;
 var EMBED_RETRY_MAX_RETRIES = 3;
 var EMBED_RETRY_MAX_DELAY_MS = 1e4;
@@ -11312,7 +11814,7 @@ async function embedWithRetry(fn) {
       isRetryable: isRetryableHttpError,
       maxDelayMs: EMBED_RETRY_MAX_DELAY_MS,
       onRetry: ({ attempt, delayMs }) => {
-        log13.warn("discovery.embed.retry", { attempt, delayMs });
+        log14.warn("discovery.embed.retry", { attempt, delayMs });
       }
     }
   );
@@ -11322,11 +11824,11 @@ async function executeDiscoveryRun(opts) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const reportOutcome = startRunOutcome(opts.db, opts.runId, "discovery", "run");
   let notConfigured = false;
-  opts.db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq16(runs.id, opts.runId)).run();
+  opts.db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq17(runs.id, opts.runId)).run();
   try {
-    const projectRow = opts.db.select().from(projects).where(eq16(projects.id, opts.projectId)).get();
+    const projectRow = opts.db.select().from(projects).where(eq17(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(eq16(competitors.projectId, opts.projectId)).orderBy(competitors.domain).all().map((r) => r.domain.toLowerCase());
+    const projectCompetitors = opts.db.select({ domain: competitors.domain }).from(competitors).where(eq17(competitors.projectId, opts.projectId)).orderBy(competitors.domain).all().map((r) => r.domain.toLowerCase());
     const canonicalDomains = effectiveDomains({
       canonicalDomain: projectRow.canonicalDomain,
       ownedDomains: projectRow.ownedDomains
@@ -11368,8 +11870,8 @@ async function executeDiscoveryRun(opts) {
       seedProvider: result.seedProvider,
       result
     });
-    opts.db.update(runs).set({ status: RunStatuses.completed, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq16(runs.id, opts.runId)).run();
-    log13.info("discovery.completed", {
+    opts.db.update(runs).set({ status: RunStatuses.completed, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq17(runs.id, opts.runId)).run();
+    log14.info("discovery.completed", {
       runId: opts.runId,
       sessionId: opts.sessionId,
       buckets: result.buckets,
@@ -11386,13 +11888,13 @@ async function executeDiscoveryRun(opts) {
     });
   } catch (err) {
     const errorMsg = describeError(err);
-    log13.error("discovery.failed", { runId: opts.runId, sessionId: opts.sessionId, error: errorMsg });
+    log14.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(eq16(runs.id, opts.runId)).run();
+    }).where(eq17(runs.id, opts.runId)).run();
     const failure2 = classifyProviderOutcomeError(err);
     reportOutcome({
       status: OutcomeStatuses.failed,
@@ -11661,13 +12163,13 @@ function writeDiscoveryInsight(db, input) {
     totalProbes
   });
   db.transaction((tx) => {
-    tx.update(insights).set({ dismissed: true }).where(and12(
-      eq16(insights.projectId, input.projectId),
-      eq16(insights.type, "discovery.basket-divergence"),
-      eq16(insights.dismissed, false)
+    tx.update(insights).set({ dismissed: true }).where(and13(
+      eq17(insights.projectId, input.projectId),
+      eq17(insights.type, "discovery.basket-divergence"),
+      eq17(insights.dismissed, false)
     )).run();
     tx.insert(insights).values({
-      id: crypto18.randomUUID(),
+      id: crypto19.randomUUID(),
       projectId: input.projectId,
       runId: input.runId,
       type: "discovery.basket-divergence",
@@ -11703,8 +12205,8 @@ function buildDiscoveryInsightTitle(input) {
 }
 
 // src/execute-site-audit.ts
-import crypto19 from "crypto";
-import { and as and14, eq as eq18, ne as ne2, sql as sql6 } from "drizzle-orm";
+import crypto20 from "crypto";
+import { and as and15, eq as eq19, ne as ne2, sql as sql7 } from "drizzle-orm";
 import { runSiteCrawl } from "@canonry/aeo-audit";
 
 // src/site-audit-root.ts
@@ -11892,7 +12394,7 @@ async function requestPinnedSiteAuditRoot(target, options) {
 }
 
 // src/site-crawl-template-links.ts
-import { and as and13, asc as asc3, eq as eq17, gt as gt2, inArray as inArray7 } from "drizzle-orm";
+import { and as and14, asc as asc3, eq as eq18, gt as gt2, inArray as inArray7 } from "drizzle-orm";
 var TEMPLATE_LINK_READ_BATCH = 2e3;
 var TEMPLATE_LINK_WRITE_BATCH = 500;
 function placementOccurrencesOf(row) {
@@ -11914,10 +12416,10 @@ function* streamAttemptEdges(db, scope) {
       placementNavigationOccurrences: siteCrawlEdges.placementNavigationOccurrences,
       placementContentOccurrences: siteCrawlEdges.placementContentOccurrences,
       placementUnknownOccurrences: siteCrawlEdges.placementUnknownOccurrences
-    }).from(siteCrawlEdges).where(and13(
-      eq17(siteCrawlEdges.projectId, scope.projectId),
-      eq17(siteCrawlEdges.runId, scope.runId),
-      eq17(siteCrawlEdges.attemptId, scope.attemptId),
+    }).from(siteCrawlEdges).where(and14(
+      eq18(siteCrawlEdges.projectId, scope.projectId),
+      eq18(siteCrawlEdges.runId, scope.runId),
+      eq18(siteCrawlEdges.attemptId, scope.attemptId),
       gt2(siteCrawlEdges.edgeKey, after)
     )).orderBy(asc3(siteCrawlEdges.edgeKey)).limit(TEMPLATE_LINK_READ_BATCH).all();
     if (rows.length === 0) return;
@@ -11942,10 +12444,10 @@ function writeGroupKey(isTemplate, templateRatio) {
   return `${isTemplate ? "1" : "0"}${templateRatio ?? ""}`;
 }
 function classifySiteCrawlTemplateLinks(db, scope, pagesFetched, placementRulesetVersion) {
-  const scopeFilter = and13(
-    eq17(siteCrawlEdges.projectId, scope.projectId),
-    eq17(siteCrawlEdges.runId, scope.runId),
-    eq17(siteCrawlEdges.attemptId, scope.attemptId)
+  const scopeFilter = and14(
+    eq18(siteCrawlEdges.projectId, scope.projectId),
+    eq18(siteCrawlEdges.runId, scope.runId),
+    eq18(siteCrawlEdges.attemptId, scope.attemptId)
   );
   const placementAvailable = templateLinkPlacementAvailable(placementRulesetVersion);
   const ubiquityAvailable = templateLinkUbiquityAvailable(pagesFetched);
@@ -11980,7 +12482,7 @@ function classifySiteCrawlTemplateLinks(db, scope, pagesFetched, placementRulese
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const group of edgeKeysByValue.values()) {
     for (const chunk of chunked(group.edgeKeys)) {
-      db.update(siteCrawlEdges).set({ isTemplate: group.isTemplate, templateRatio: group.templateRatio, updatedAt: now }).where(and13(scopeFilter, inArray7(siteCrawlEdges.edgeKey, chunk))).run();
+      db.update(siteCrawlEdges).set({ isTemplate: group.isTemplate, templateRatio: group.templateRatio, updatedAt: now }).where(and14(scopeFilter, inArray7(siteCrawlEdges.edgeKey, chunk))).run();
     }
   }
   return {
@@ -12016,7 +12518,7 @@ function buildSiteCrawlIssueEvidence(siteIssues, pages) {
 }
 
 // src/execute-site-audit.ts
-var log14 = createLogger("SiteAudit");
+var log15 = createLogger("SiteAudit");
 var SiteAuditCancelledError = class extends Error {
   name = "SiteAuditCancelledError";
 };
@@ -12168,7 +12670,7 @@ function trackSiteAuditOutcome(db, input) {
     );
     const pagesAudited = input.crawl?.pagesAudited ?? 0;
     if (pagesAudited === 0 || input.trigger === RunTriggers.probe) return;
-    const prior = db.select({ id: siteAuditSnapshots.id }).from(siteAuditSnapshots).where(and14(eq18(siteAuditSnapshots.projectId, input.projectId), ne2(siteAuditSnapshots.runId, input.runId))).limit(1).get();
+    const prior = db.select({ id: siteAuditSnapshots.id }).from(siteAuditSnapshots).where(and15(eq19(siteAuditSnapshots.projectId, input.projectId), ne2(siteAuditSnapshots.runId, input.runId))).limit(1).get();
     if (prior) return;
     trackEvent("activation.completed", {
       flowVersion: ONBOARDING_FLOW_VERSION,
@@ -12177,18 +12679,18 @@ function trackSiteAuditOutcome(db, input) {
       pagesAuditedBucket: bucketOnboardingCount(pagesAudited)
     });
   } catch (error) {
-    log14.warn("telemetry.failed", { runId: input.runId, projectId: input.projectId, error: describeError(error) });
+    log15.warn("telemetry.failed", { runId: input.runId, projectId: input.projectId, error: describeError(error) });
   }
 }
 async function executeSiteAudit(db, runId, projectId, opts = {}) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const claim = db.update(runs).set({ status: "running", startedAt }).where(and14(eq18(runs.id, runId), eq18(runs.projectId, projectId), eq18(runs.status, "queued"))).run();
+  const claim = db.update(runs).set({ status: "running", startedAt }).where(and15(eq19(runs.id, runId), eq19(runs.projectId, projectId), eq19(runs.status, "queued"))).run();
   if (claim.changes === 0) return;
   const startTime = Date.now();
-  const trigger = db.select({ trigger: runs.trigger }).from(runs).where(eq18(runs.id, runId)).get()?.trigger ?? null;
+  const trigger = db.select({ trigger: runs.trigger }).from(runs).where(eq19(runs.id, runId)).get()?.trigger ?? null;
   let canonicalDomain = null;
-  const attemptNumber = (db.select({ value: sql6`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq18(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
-  const attemptId = crypto19.randomUUID();
+  const attemptNumber = (db.select({ value: sql7`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq19(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
+  const attemptId = crypto20.randomUUID();
   db.insert(siteCrawlAttempts).values({
     id: attemptId,
     projectId,
@@ -12222,22 +12724,22 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       const nodeKey = nodeKeyByUrl.get(url);
       if (!nodeKey) continue;
       const scope = [
-        eq18(siteCrawlEdges.projectId, projectId),
-        eq18(siteCrawlEdges.runId, runId),
-        eq18(siteCrawlEdges.attemptId, attemptId)
+        eq19(siteCrawlEdges.projectId, projectId),
+        eq19(siteCrawlEdges.runId, runId),
+        eq19(siteCrawlEdges.attemptId, attemptId)
       ];
-      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and14(
+      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and15(
         ...scope,
-        eq18(siteCrawlEdges.sourceUrl, url)
+        eq19(siteCrawlEdges.sourceUrl, url)
       )).run();
-      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and14(
+      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and15(
         ...scope,
-        eq18(siteCrawlEdges.targetUrl, url)
+        eq19(siteCrawlEdges.targetUrl, url)
       )).run();
       const pageScope = [
-        eq18(siteCrawlPages.projectId, projectId),
-        eq18(siteCrawlPages.runId, runId),
-        eq18(siteCrawlPages.attemptId, attemptId)
+        eq19(siteCrawlPages.projectId, projectId),
+        eq19(siteCrawlPages.runId, runId),
+        eq19(siteCrawlPages.attemptId, attemptId)
       ];
       const canonicalTargets = tx.select({
         id: siteCrawlPages.id,
@@ -12245,13 +12747,13 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         fetchState: siteCrawlPages.fetchState,
         indexabilityState: siteCrawlPages.indexabilityState,
         indexabilityReasons: siteCrawlPages.indexabilityReasons
-      }).from(siteCrawlPages).where(and14(...pageScope, eq18(siteCrawlPages.canonicalUrl, url))).all();
+      }).from(siteCrawlPages).where(and15(...pageScope, eq19(siteCrawlPages.canonicalUrl, url))).all();
       for (const target of canonicalTargets) {
         tx.update(siteCrawlPages).set({
           canonicalNodeKey: nodeKey,
           healthState: deriveSiteHealthState({ ...target, canonicalNodeKey: nodeKey }),
           updatedAt: now
-        }).where(eq18(siteCrawlPages.id, target.id)).run();
+        }).where(eq19(siteCrawlPages.id, target.id)).run();
       }
     }
   };
@@ -12267,7 +12769,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       nodeKey: page.key
     });
     tx.insert(siteCrawlPages).values({
-      id: crypto19.randomUUID(),
+      id: crypto20.randomUUID(),
       projectId,
       runId,
       attemptId,
@@ -12318,7 +12820,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         discoveryProvenance: [{ discoveredFrom: page.provenance.discoveredFrom, sitemapSources: page.provenance.sitemapSources, root: page.provenance.root }],
         sitemapMetadata: { sources: page.provenance.sitemapSources },
         fetchState: page.state,
-        fetchedAt: page.state === "discovered" || page.state === "robots-blocked" ? null : sql6`coalesce(${siteCrawlPages.fetchedAt}, ${now})`,
+        fetchedAt: page.state === "discovered" || page.state === "robots-blocked" ? null : sql7`coalesce(${siteCrawlPages.fetchedAt}, ${now})`,
         httpStatus: page.statusCode,
         contentType: page.contentType,
         finalUrl: page.finalUrl,
@@ -12362,7 +12864,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     if (isSelfLink(edge.from, edge.to)) return;
     observedEdges.set(edge.key, edge);
     tx.insert(siteCrawlEdges).values({
-      id: crypto19.randomUUID(),
+      id: crypto20.randomUUID(),
       projectId,
       runId,
       attemptId,
@@ -12410,20 +12912,20 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       linkScoreRaw: metrics.linkScoreRaw,
       linkScoreNormalized: metrics.linkScore,
       updatedAt: now
-    }).where(and14(
-      eq18(siteCrawlPages.projectId, projectId),
-      eq18(siteCrawlPages.runId, runId),
-      eq18(siteCrawlPages.attemptId, attemptId),
-      eq18(siteCrawlPages.nodeKey, key)
+    }).where(and15(
+      eq19(siteCrawlPages.projectId, projectId),
+      eq19(siteCrawlPages.runId, runId),
+      eq19(siteCrawlPages.attemptId, attemptId),
+      eq19(siteCrawlPages.nodeKey, key)
     )).run();
   };
   const persistEvent = async (event) => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     db.transaction((tx) => {
-      const receipt = tx.select({ checksum: siteCrawlEventReceipts.checksum }).from(siteCrawlEventReceipts).where(and14(
-        eq18(siteCrawlEventReceipts.attemptId, attemptId),
-        eq18(siteCrawlEventReceipts.sequence, event.sequence),
-        eq18(siteCrawlEventReceipts.batchId, event.batchId)
+      const receipt = tx.select({ checksum: siteCrawlEventReceipts.checksum }).from(siteCrawlEventReceipts).where(and15(
+        eq19(siteCrawlEventReceipts.attemptId, attemptId),
+        eq19(siteCrawlEventReceipts.sequence, event.sequence),
+        eq19(siteCrawlEventReceipts.batchId, event.batchId)
       )).get();
       if (receipt) {
         if (receipt.checksum !== event.checksum) {
@@ -12432,7 +12934,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         return;
       }
       tx.insert(siteCrawlEventReceipts).values({
-        id: crypto19.randomUUID(),
+        id: crypto20.randomUUID(),
         projectId,
         runId,
         attemptId,
@@ -12452,24 +12954,24 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           lastEventChecksum: event.checksum,
           pagesDiscovered: progress.pagesDiscovered,
           pagesFetched: progress.pagesFetched,
-          pagesEligible: event.type === "summary" ? observedPages.size === 0 ? 0 : [...observedPages.values()].filter(isInventoryEligible).length : sql6`${siteCrawlAttempts.pagesEligible}`,
-          pagesErrored: event.type === "summary" ? observedErrorCount(observedPages.values()) : sql6`${siteCrawlAttempts.pagesErrored}`,
+          pagesEligible: event.type === "summary" ? observedPages.size === 0 ? 0 : [...observedPages.values()].filter(isInventoryEligible).length : sql7`${siteCrawlAttempts.pagesEligible}`,
+          pagesErrored: event.type === "summary" ? observedErrorCount(observedPages.values()) : sql7`${siteCrawlAttempts.pagesErrored}`,
           // Only the summary knows how many URL versions the crawl left unfetched.
-          urlVersionsSkipped: event.type === "summary" ? event.summary.urlVersions?.skipped ?? 0 : sql6`${siteCrawlAttempts.urlVersionsSkipped}`,
+          urlVersionsSkipped: event.type === "summary" ? event.summary.urlVersions?.skipped ?? 0 : sql7`${siteCrawlAttempts.urlVersionsSkipped}`,
           edgesDiscovered: progress.edgesObserved,
           updatedAt: now
-        }).where(eq18(siteCrawlAttempts.id, attemptId)).run();
+        }).where(eq19(siteCrawlAttempts.id, attemptId)).run();
       } else {
         tx.update(siteCrawlAttempts).set({
           lastEventSequence: event.sequence,
           lastEventChecksum: event.checksum,
           updatedAt: now
-        }).where(eq18(siteCrawlAttempts.id, attemptId)).run();
+        }).where(eq19(siteCrawlAttempts.id, attemptId)).run();
       }
     });
   };
   try {
-    const project = db.select().from(projects).where(eq18(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq19(projects.id, projectId)).get();
     if (!project) throw new Error(`Project not found: ${projectId}`);
     canonicalDomain = project.canonicalDomain;
     const homepageUrl = toHomepageUrl(project.canonicalDomain);
@@ -12481,7 +12983,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     });
     const crawlRootUrl = resolvedRoot.effectiveUrl;
     if (opts.sitemapUrl) await assertSiteAuditUrlAllowed(opts.sitemapUrl, "sitemapUrl");
-    log14.info("start", {
+    log15.info("start", {
       runId,
       projectId,
       homepageUrl,
@@ -12515,7 +13017,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       crawlSummary.pagesFetched,
       placementRulesetVersion
     );
-    log14.info("template-links", {
+    log15.info("template-links", {
       runId,
       projectId,
       detection: templateLinks.detection,
@@ -12547,7 +13049,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     try {
       persistSiteCrawlGraphLayout(db, { projectId, runId, attemptId }, graphLayout, finishedAt);
     } catch (error) {
-      log14.warn("graph-layout.persist-failed", {
+      log15.warn("graph-layout.persist-failed", {
         runId,
         projectId,
         error: describeError(error)
@@ -12565,7 +13067,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           edges: []
         }, finishedAt);
       } catch (markerError) {
-        log14.warn("graph-layout.marker-persist-failed", {
+        log15.warn("graph-layout.marker-persist-failed", {
           runId,
           projectId,
           error: describeError(markerError)
@@ -12573,11 +13075,11 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       }
     }
     const published = db.transaction((tx) => {
-      const claim2 = tx.update(runs).set({ status: terminalStatus, finishedAt }).where(and14(eq18(runs.id, runId), eq18(runs.status, "running"))).run();
+      const claim2 = tx.update(runs).set({ status: terminalStatus, finishedAt }).where(and15(eq19(runs.id, runId), eq19(runs.status, "running"))).run();
       if (claim2.changes === 0) return false;
       if (aggregateScore !== null) {
         tx.insert(siteAuditSnapshots).values({
-          id: crypto19.randomUUID(),
+          id: crypto20.randomUUID(),
           projectId,
           runId,
           sitemapUrl: opts.sitemapUrl ?? new URL("/sitemap.xml", crawlRootUrl).href,
@@ -12595,7 +13097,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         for (const page of observedPages.values()) {
           if (!isLegacyScorecardPage(page)) continue;
           tx.insert(siteAuditPages).values({
-            id: crypto19.randomUUID(),
+            id: crypto20.randomUUID(),
             projectId,
             runId,
             url: page.finalUrl ?? page.requestedUrl,
@@ -12608,7 +13110,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         }
       }
       tx.insert(siteCrawlSnapshots).values({
-        id: crypto19.randomUUID(),
+        id: crypto20.randomUUID(),
         projectId,
         runId,
         attemptId,
@@ -12657,7 +13159,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       if (opts.checkDeadLinks) {
         for (const finding of deadLinkFindings) {
           tx.insert(siteCrawlFindings).values({
-            id: crypto19.randomUUID(),
+            id: crypto20.randomUUID(),
             projectId,
             runId,
             attemptId,
@@ -12683,24 +13185,24 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         edgesDiscovered: crawlSummary.edgesObserved,
         finishedAt,
         updatedAt: finishedAt
-      }).where(eq18(siteCrawlAttempts.id, attemptId)).run();
+      }).where(eq19(siteCrawlAttempts.id, attemptId)).run();
       return true;
     });
     if (!published) {
       try {
         deleteSiteCrawlGraphLayout(db, { projectId, runId, attemptId });
       } catch (cleanupError) {
-        log14.warn("graph-layout.cleanup-failed", {
+        log15.warn("graph-layout.cleanup-failed", {
           runId,
           projectId,
           error: describeError(cleanupError)
         });
       }
-      const current = db.select({ status: runs.status }).from(runs).where(eq18(runs.id, runId)).get();
+      const current = db.select({ status: runs.status }).from(runs).where(eq19(runs.id, runId)).get();
       if (current?.status === "cancelled") throw new SiteAuditCancelledError(`Site audit cancelled before publication: ${runId}`);
       throw new Error(`Site audit run was no longer running before publication: ${runId}`);
     }
-    log14.info("completed", {
+    log15.info("completed", {
       runId,
       projectId,
       status: terminalStatus,
@@ -12744,14 +13246,14 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         error: message,
         finishedAt,
         updatedAt: finishedAt
-      }).where(eq18(siteCrawlAttempts.id, attemptId)).run();
+      }).where(eq19(siteCrawlAttempts.id, attemptId)).run();
       tx.update(runs).set({
         status: cancelled ? "cancelled" : "failed",
         error: message,
         finishedAt
-      }).where(and14(eq18(runs.id, runId), eq18(runs.status, "running"))).run();
+      }).where(and15(eq19(runs.id, runId), eq19(runs.status, "running"))).run();
     });
-    log14.error("failed", { runId, projectId, cancelled, error: message });
+    log15.error("failed", { runId, projectId, cancelled, error: message });
     trackSiteAuditOutcome(db, {
       runId,
       projectId,
@@ -12787,7 +13289,7 @@ function createAnswerFieldRecomputeQueue(opts) {
 
 // src/competitor-auto-alias-runner.ts
 import { setImmediate as yieldToEventLoop3 } from "timers/promises";
-var log15 = createLogger("CompetitorAutoAliases");
+var log16 = createLogger("CompetitorAutoAliases");
 function createCompetitorAutoAliasRunner(opts) {
   const reasons = /* @__PURE__ */ new Map();
   const queue = createProjectPassQueue(async (projectId) => {
@@ -12798,7 +13300,7 @@ function createCompetitorAutoAliasRunner(opts) {
     if (!result) return null;
     const added = result.detection.competitors.reduce((sum, competitor) => sum + competitor.added.length, 0);
     const removed = result.detection.competitors.reduce((sum, competitor) => sum + competitor.removed.length, 0);
-    log15.info("detection.completed", {
+    log16.info("detection.completed", {
       projectId,
       reason,
       runs: result.detection.scan.runs,
@@ -12811,7 +13313,7 @@ function createCompetitorAutoAliasRunner(opts) {
       try {
         opts.onNamesChanged(projectId, result.detection.project);
       } catch (err) {
-        log15.error("names-changed.failed", { projectId, error: describeError(err) });
+        log16.error("names-changed.failed", { projectId, error: describeError(err) });
       }
     }
     return result;
@@ -12823,14 +13325,14 @@ function createCompetitorAutoAliasRunner(opts) {
   return {
     schedule(projectId, reason) {
       enqueue(projectId, reason).catch((err) => {
-        log15.error("detection.failed", { projectId, reason, error: describeError(err) });
+        log16.error("detection.failed", { projectId, reason, error: describeError(err) });
       });
     },
     async request(projectId, reason) {
       try {
         return await enqueue(projectId, reason);
       } catch (err) {
-        log15.error("detection.failed", { projectId, reason, error: describeError(err) });
+        log16.error("detection.failed", { projectId, reason, error: describeError(err) });
         throw err;
       }
     },
@@ -12947,8 +13449,8 @@ function derivedRouteAdapter(adapter, route) {
 }
 
 // src/install-state-telemetry.ts
-import { and as and15, count as count3, eq as eq19, gte as gte2, inArray as inArray8, isNotNull as isNotNull2, isNull as isNull2, ne as ne3, sql as sql7 } from "drizzle-orm";
-var log16 = createLogger("InstallStateTelemetry");
+import { and as and16, count as count4, eq as eq20, gte as gte2, inArray as inArray8, isNotNull as isNotNull2, isNull as isNull2, ne as ne3, sql as sql8 } from "drizzle-orm";
+var log17 = createLogger("InstallStateTelemetry");
 var INSTALL_STATE_FIRST_DELAY_MS = 5 * 6e4;
 var INSTALL_STATE_INTERVAL_MS = 24 * 60 * 6e4;
 var KNOWN_PROVIDERS2 = new Set(PROVIDER_NAMES);
@@ -12970,31 +13472,31 @@ function buildInstallState(sources, now, startedAt) {
   const since = new Date(now - INSTALL_STATE_INTERVAL_MS).toISOString();
   const projectIds = db.select({ id: projects.id }).from(projects);
   const total = (query) => whole(query.get()?.value);
-  const googleByType = new Map(db.select({ type: googleConnections.connectionType, value: count3() }).from(googleConnections).groupBy(googleConnections.connectionType).all().map((row) => [row.type, whole(row.value)]));
-  const gaServiceAccounts = total(db.select({ value: count3() }).from(gaConnections));
-  const trafficByType = db.select({ type: trafficSources.sourceType, value: count3() }).from(trafficSources).where(and15(isNull2(trafficSources.archivedAt), ne3(trafficSources.status, TrafficSourceStatuses.archived))).groupBy(trafficSources.sourceType).all();
-  const webhookSources = db.select({ config: notifications.config }).from(notifications).where(eq19(notifications.enabled, true)).all().map((row) => row.config.source);
+  const googleByType = new Map(db.select({ type: googleConnections.connectionType, value: count4() }).from(googleConnections).groupBy(googleConnections.connectionType).all().map((row) => [row.type, whole(row.value)]));
+  const gaServiceAccounts = total(db.select({ value: count4() }).from(gaConnections));
+  const trafficByType = db.select({ type: trafficSources.sourceType, value: count4() }).from(trafficSources).where(and16(isNull2(trafficSources.archivedAt), ne3(trafficSources.status, TrafficSourceStatuses.archived))).groupBy(trafficSources.sourceType).all();
+  const webhookSources = db.select({ config: notifications.config }).from(notifications).where(eq20(notifications.enabled, true)).all().map((row) => row.config.source);
   const agentWebhooks = webhookSources.filter((source) => source === AGENT_WEBHOOK_SOURCE).length;
   const webhooks = webhookSources.length - agentWebhooks;
-  const bing = total(db.select({ value: count3() }).from(bingConnections));
-  const openAiAds = total(db.select({ value: count3() }).from(adsConnections));
-  const googleAdsConnected = total(db.select({ value: count3() }).from(googleAdsConnections));
-  const backlinkSources = total(db.select({ value: count3() }).from(
+  const bing = total(db.select({ value: count4() }).from(bingConnections));
+  const openAiAds = total(db.select({ value: count4() }).from(adsConnections));
+  const googleAdsConnected = total(db.select({ value: count4() }).from(googleAdsConnections));
+  const backlinkSources = total(db.select({ value: count4() }).from(
     db.selectDistinct({ projectId: backlinkSummaries.projectId, source: backlinkSummaries.source }).from(backlinkSummaries).as("backlink_sources")
   ));
   const counts = {
-    projects: total(db.select({ value: count3() }).from(projects)),
-    queries: total(db.select({ value: count3() }).from(queries)),
-    competitors: total(db.select({ value: count3() }).from(competitors)),
-    locations: total(db.select({ value: sql7`coalesce(sum(json_array_length(${projects.locations})), 0)` }).from(projects)),
-    schedules: total(db.select({ value: count3() }).from(schedules).where(eq19(schedules.enabled, true))),
+    projects: total(db.select({ value: count4() }).from(projects)),
+    queries: total(db.select({ value: count4() }).from(queries)),
+    competitors: total(db.select({ value: count4() }).from(competitors)),
+    locations: total(db.select({ value: sql8`coalesce(sum(json_array_length(${projects.locations})), 0)` }).from(projects)),
+    schedules: total(db.select({ value: count4() }).from(schedules).where(eq20(schedules.enabled, true))),
     webhooks,
     agentWebhooks,
     trafficSources: trafficByType.reduce((sum, row) => sum + whole(row.value), 0),
     googleConnections: [...googleByType.values()].reduce((sum, value) => sum + value, 0) + gaServiceAccounts,
     bingConnections: bing,
     backlinkSources,
-    adsAccounts: openAiAds + total(db.select({ value: count3() }).from(googleAdsConnections).where(isNotNull2(googleAdsConnections.selectedCustomerId)))
+    adsAccounts: openAiAds + total(db.select({ value: count4() }).from(googleAdsConnections).where(isNotNull2(googleAdsConnections.selectedCustomerId)))
   };
   const connected = /* @__PURE__ */ new Set();
   if ((googleByType.get("gsc") ?? 0) > 0) connected.add(IntegrationNames.gsc);
@@ -13002,7 +13504,7 @@ function buildInstallState(sources, now, startedAt) {
   if ((googleByType.get("gbp") ?? 0) > 0) connected.add(IntegrationNames.gbp);
   if (bing > 0) connected.add(IntegrationNames.bing);
   if (googleAdsConnected > 0) connected.add(IntegrationNames.google_ads);
-  if (total(db.select({ value: count3() }).from(gtmConnections)) > 0) connected.add(IntegrationNames.gtm);
+  if (total(db.select({ value: count4() }).from(gtmConnections)) > 0) connected.add(IntegrationNames.gtm);
   if (openAiAds > 0) connected.add(IntegrationNames.openai_ads);
   for (const row of trafficByType) {
     const integration = TRAFFIC_INTEGRATIONS[row.type];
@@ -13020,25 +13522,25 @@ function buildInstallState(sources, now, startedAt) {
     if (!KNOWN_PROVIDERS2.has(connection)) return;
     providerCalls.set(connection, (providerCalls.get(connection) ?? 0) + calls);
   };
-  const usagePath = (field) => sql7`json_extract(${querySnapshots.usage}, ${`$.${field}`})`;
+  const usagePath = (field) => sql8`json_extract(${querySnapshots.usage}, ${`$.${field}`})`;
   const answers = db.select({
     provider: querySnapshots.provider,
-    answers: count3(),
-    measured: sql7`sum(case when ${usagePath("inputTokens")} is not null then 1 else 0 end)`,
-    unpriced: sql7`sum(case when ${usagePath("inputTokens")} is not null and ${usagePath("estimatedCostMicros")} is null then 1 else 0 end)`,
-    inputTokens: sql7`coalesce(sum(${usagePath("inputTokens")}), 0)`,
-    outputTokens: sql7`coalesce(sum(${usagePath("outputTokens")}), 0)`,
-    costMicros: sql7`coalesce(sum(${usagePath("estimatedCostMicros")}), 0)`
-  }).from(querySnapshots).where(gte2(querySnapshots.createdAt, since)).groupBy(sql7`+${querySnapshots.provider}`).all();
+    answers: count4(),
+    measured: sql8`sum(case when ${usagePath("inputTokens")} is not null then 1 else 0 end)`,
+    unpriced: sql8`sum(case when ${usagePath("inputTokens")} is not null and ${usagePath("estimatedCostMicros")} is null then 1 else 0 end)`,
+    inputTokens: sql8`coalesce(sum(${usagePath("inputTokens")}), 0)`,
+    outputTokens: sql8`coalesce(sum(${usagePath("outputTokens")}), 0)`,
+    costMicros: sql8`coalesce(sum(${usagePath("estimatedCostMicros")}), 0)`
+  }).from(querySnapshots).where(gte2(querySnapshots.createdAt, since)).groupBy(sql8`+${querySnapshots.provider}`).all();
   for (const row of answers) addCalls(row.provider, whole(row.answers));
-  for (const row of db.select({ provider: researchRuns.provider, answered: sql7`coalesce(sum(${researchRuns.completedQueries}), 0)` }).from(researchRuns).where(and15(inArray8(researchRuns.projectId, projectIds), gte2(researchRuns.createdAt, since))).groupBy(researchRuns.provider).all()) {
+  for (const row of db.select({ provider: researchRuns.provider, answered: sql8`coalesce(sum(${researchRuns.completedQueries}), 0)` }).from(researchRuns).where(and16(inArray8(researchRuns.projectId, projectIds), gte2(researchRuns.createdAt, since))).groupBy(researchRuns.provider).all()) {
     addCalls(row.provider, whole(row.answered));
   }
   for (const session of db.select({
     seedProviders: discoverySessions.seedProviders,
     seedCountRaw: discoverySessions.seedCountRaw,
     probeCount: discoverySessions.probeCount
-  }).from(discoverySessions).where(and15(inArray8(discoverySessions.projectId, projectIds), gte2(discoverySessions.createdAt, since))).all()) {
+  }).from(discoverySessions).where(and16(inArray8(discoverySessions.projectId, projectIds), gte2(discoverySessions.createdAt, since))).all()) {
     if (session.seedCountRaw !== null) {
       for (const provider of session.seedProviders?.length ? session.seedProviders : [ProviderNames.gemini]) addCalls(provider, 1);
     }
@@ -13047,15 +13549,15 @@ function buildInstallState(sources, now, startedAt) {
   const answered = answers.reduce((sum, row) => sum + whole(row.answers), 0);
   const measured = answers.reduce((sum, row) => sum + whole(row.measured), 0);
   const usage24h = {
-    sweeps: total(db.select({ value: count3() }).from(runs).where(and15(
+    sweeps: total(db.select({ value: count4() }).from(runs).where(and16(
       inArray8(runs.projectId, projectIds),
-      eq19(runs.kind, RunKinds["answer-visibility"]),
+      eq20(runs.kind, RunKinds["answer-visibility"]),
       gte2(runs.createdAt, since),
       ne3(runs.trigger, RunTriggers.probe)
     ))),
-    audits: total(db.select({ value: count3() }).from(runs).where(and15(
+    audits: total(db.select({ value: count4() }).from(runs).where(and16(
       inArray8(runs.projectId, projectIds),
-      eq19(runs.kind, RunKinds["site-audit"]),
+      eq20(runs.kind, RunKinds["site-audit"]),
       gte2(runs.createdAt, since)
     ))),
     providerCalls: [...providerCalls.values()].reduce((sum, calls) => sum + calls, 0)
@@ -13068,18 +13570,18 @@ function buildInstallState(sources, now, startedAt) {
     }
   }
   const aero = db.select({
-    calls: count3(),
-    inputTokens: sql7`coalesce(sum(${llmUsageEvents.inputTokens}), 0)`,
-    outputTokens: sql7`coalesce(sum(${llmUsageEvents.outputTokens}), 0)`,
-    costMillicents: sql7`coalesce(sum(${llmUsageEvents.costMillicents}), 0)`
-  }).from(llmUsageEvents).where(and15(eq19(llmUsageEvents.feature, AeroLlmUsageFeatures.turn), gte2(llmUsageEvents.createdAt, since))).get();
+    calls: count4(),
+    inputTokens: sql8`coalesce(sum(${llmUsageEvents.inputTokens}), 0)`,
+    outputTokens: sql8`coalesce(sum(${llmUsageEvents.outputTokens}), 0)`,
+    costMillicents: sql8`coalesce(sum(${llmUsageEvents.costMillicents}), 0)`
+  }).from(llmUsageEvents).where(and16(eq20(llmUsageEvents.feature, AeroLlmUsageFeatures.turn), gte2(llmUsageEvents.createdAt, since))).get();
   const aeroCalls = whole(aero?.calls);
   usage24h.aeroModelCalls = aeroCalls;
   usage24h.aeroInputTokens = whole(aero?.inputTokens);
   usage24h.aeroOutputTokens = whole(aero?.outputTokens);
   const aeroMillicents = whole(aero?.costMillicents);
   if (aeroCalls === 0 || aeroMillicents > 0) usage24h.aeroCostMicros = aeroMillicents * 10;
-  usage24h.webhookDeliveries = total(db.select({ value: count3() }).from(auditLog).where(and15(gte2(auditLog.createdAt, since), eq19(auditLog.action, WEBHOOK_DELIVERED_ACTION))));
+  usage24h.webhookDeliveries = total(db.select({ value: count4() }).from(auditLog).where(and16(gte2(auditLog.createdAt, since), eq20(auditLog.action, WEBHOOK_DELIVERED_ACTION))));
   const providerCalls24h = Object.fromEntries(PROVIDER_NAMES.flatMap((name) => providerCalls.has(name) ? [[name, providerCalls.get(name)]] : []));
   return {
     providers: registeredProviderNames(config).filter((name) => KNOWN_PROVIDERS2.has(name)),
@@ -13113,7 +13615,7 @@ function startInstallStateTelemetry(sources) {
     try {
       if (isTelemetryEnabled()) trackInstallState(buildInstallState(sources, Date.now(), startedAt));
     } catch (err) {
-      log16.warn("telemetry.install-state-failed", { error: describeError(err) });
+      log17.warn("telemetry.install-state-failed", { error: describeError(err) });
     }
     schedule(INSTALL_STATE_INTERVAL_MS);
   };
@@ -13209,7 +13711,7 @@ function configuredProviderEntries(config, apiAdapters, cdpAdapter) {
 
 // src/provider-reload-batch-guard.ts
 import { isDeepStrictEqual } from "util";
-import { and as and16, inArray as inArray9 } from "drizzle-orm";
+import { and as and17, inArray as inArray9 } from "drizzle-orm";
 function pendingBatchIdentity(provider) {
   const { quotaPolicy: _quotaPolicy, ...identity } = resolveRegistration(provider.adapter, provider.config).config;
   return identity;
@@ -13223,7 +13725,7 @@ function assertProviderReloadKeepsPendingBatches(db, previous, next, executing =
   const changed = previous.filter(changedRegistration).map((provider) => provider.adapter.name);
   const active = executing.filter((snapshot) => changedRegistration(snapshot.registration));
   if (changed.length === 0 && active.length === 0) return;
-  const pending = changed.length === 0 ? [] : db.select({ id: providerBatches.id, provider: providerBatches.provider, runId: providerBatches.runId }).from(providerBatches).where(and16(
+  const pending = changed.length === 0 ? [] : db.select({ id: providerBatches.id, provider: providerBatches.provider, runId: providerBatches.runId }).from(providerBatches).where(and17(
     inArray9(providerBatches.provider, changed),
     inArray9(providerBatches.status, [ProviderBatchStatuses.submitting, ProviderBatchStatuses.submitted, ProviderBatchStatuses.ended])
   )).all();
@@ -13303,10 +13805,10 @@ function createProviderModelCatalog(registry) {
 }
 
 // src/scheduler.ts
-import crypto20 from "crypto";
+import crypto21 from "crypto";
 import cron from "node-cron";
-import { and as and17, eq as eq20, inArray as inArray10, notExists, sql as sql8 } from "drizzle-orm";
-var log17 = createLogger("Scheduler");
+import { and as and18, eq as eq21, inArray as inArray10, notExists, sql as sql9 } from "drizzle-orm";
+var log18 = createLogger("Scheduler");
 var SLOT_FIRED = { status: OutcomeStatuses.succeeded };
 var slotSkipped = (reasonCode) => ({ status: OutcomeStatuses.skipped, reasonCode });
 var slotFailed = (reasonCode) => ({ status: OutcomeStatuses.failed, reasonCode });
@@ -13315,7 +13817,7 @@ var SCHEDULE_SPREAD_MS = 12e4;
 var UNSPREAD_KINDS = /* @__PURE__ */ new Set([SchedulableRunKinds["answer-visibility"]]);
 function scheduleSpreadMs(projectId, kind, spreadMs = SCHEDULE_SPREAD_MS) {
   if (spreadMs <= 0) return 0;
-  return crypto20.createHash("sha256").update(`${projectId}:${kind}`).digest().readUInt32BE(0) % spreadMs;
+  return crypto21.createHash("sha256").update(`${projectId}:${kind}`).digest().readUInt32BE(0) % spreadMs;
 }
 function shortestCronGapMs(cronExpr, timezone, from = /* @__PURE__ */ new Date()) {
   let previous = nextRunFromCron(cronExpr, timezone, from);
@@ -13330,7 +13832,7 @@ function shortestCronGapMs(cronExpr, timezone, from = /* @__PURE__ */ new Date()
 }
 function ensureDefaultHealthSchedule(db, projectId, now = (/* @__PURE__ */ new Date()).toISOString()) {
   const result = db.insert(schedules).values({
-    id: crypto20.randomUUID(),
+    id: crypto21.randomUUID(),
     projectId,
     kind: SchedulableRunKinds.doctor,
     cronExpr: DEFAULT_HEALTH_CRON,
@@ -13384,9 +13886,9 @@ var Scheduler = class {
    */
   ensureHealthSchedules() {
     const projectsWithoutHealth = this.db.select({ id: projects.id }).from(projects).where(notExists(
-      this.db.select({ one: sql8`1` }).from(schedules).where(and17(
-        eq20(schedules.projectId, projects.id),
-        eq20(schedules.kind, SchedulableRunKinds.doctor)
+      this.db.select({ one: sql9`1` }).from(schedules).where(and18(
+        eq21(schedules.projectId, projects.id),
+        eq21(schedules.kind, SchedulableRunKinds.doctor)
       ))
     )).all();
     if (projectsWithoutHealth.length === 0) return;
@@ -13396,7 +13898,7 @@ var Scheduler = class {
       if (ensureDefaultHealthSchedule(this.db, project.id, now)) seeded += 1;
     }
     if (seeded > 0) {
-      log17.info("health-schedule.seeded", { projectCount: seeded, cron: DEFAULT_HEALTH_CRON });
+      log18.info("health-schedule.seeded", { projectCount: seeded, cron: DEFAULT_HEALTH_CRON });
     }
   }
   /**
@@ -13420,16 +13922,16 @@ var Scheduler = class {
         const current = ensureCurrentQueryBasketRevision(this.db, project.id);
         if (current !== null && current.revision !== previous) minted += 1;
       } catch (err) {
-        log17.warn("query-basket.mint-failed", { projectId: project.id, err: String(err) });
+        log18.warn("query-basket.mint-failed", { projectId: project.id, err: String(err) });
       }
     }
-    if (minted > 0) log17.info("query-basket.ensured", { projectCount: minted });
+    if (minted > 0) log18.info("query-basket.ensured", { projectCount: minted });
   }
   /** Load all enabled schedules from DB and register cron jobs. */
   start() {
     this.ensureHealthSchedules();
     this.ensureQueryBaskets();
-    const allSchedules = this.db.select().from(schedules).where(eq20(schedules.enabled, true)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq21(schedules.enabled, true)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       const recurrence = scheduleRecurrence(schedule);
@@ -13437,12 +13939,12 @@ var Scheduler = class {
       if (registered && missedRunAt && new Date(missedRunAt) < /* @__PURE__ */ new Date()) {
         const answerRecurrence = recurrence && schedule.kind === SchedulableRunKinds["answer-visibility"];
         if (!recurrence || answerRecurrence || this.claimCalendarOccurrence(schedule, missedRunAt, /* @__PURE__ */ new Date())) {
-          log17.info("run.catch-up", { projectId: schedule.projectId, kind: schedule.kind, missedRunAt });
+          log18.info("run.catch-up", { projectId: schedule.projectId, kind: schedule.kind, missedRunAt });
           this.triggerRun(schedule.id, schedule.projectId, schedule.kind, answerRecurrence ? missedRunAt : void 0, OutcomeTriggers.startup);
         }
       }
     }
-    log17.info("started", { scheduleCount: allSchedules.length });
+    log18.info("started", { scheduleCount: allSchedules.length });
   }
   /** Stop all cron tasks for graceful shutdown. */
   stop() {
@@ -13463,7 +13965,7 @@ var Scheduler = class {
       this.stopTask(key, existing, "Stopped");
       this.tasks.delete(key);
     }
-    const schedule = this.db.select().from(schedules).where(and17(eq20(schedules.projectId, projectId), eq20(schedules.kind, kind))).get();
+    const schedule = this.db.select().from(schedules).where(and18(eq21(schedules.projectId, projectId), eq21(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -13491,17 +13993,17 @@ var Scheduler = class {
       clearTimeout(pending);
       this.spreadTimers.delete(key);
     }
-    log17.info(`task.${verb.toLowerCase()}`, { key });
+    log18.info(`task.${verb.toLowerCase()}`, { key });
   }
   /** Runtime timing writes must not restore a version already issued to a settings caller. */
   updateScheduleTiming(scheduleId, timing) {
     this.db.transaction((tx) => {
-      const current = tx.select({ updatedAt: schedules.updatedAt }).from(schedules).where(eq20(schedules.id, scheduleId)).get();
+      const current = tx.select({ updatedAt: schedules.updatedAt }).from(schedules).where(eq21(schedules.id, scheduleId)).get();
       if (!current) return;
       tx.update(schedules).set({
         ...timing,
         updatedAt: nextScheduleUpdatedAt(current.updatedAt)
-      }).where(eq20(schedules.id, scheduleId)).run();
+      }).where(eq21(schedules.id, scheduleId)).run();
     });
   }
   registerCronTask(schedule, options = {}) {
@@ -13511,13 +14013,13 @@ var Scheduler = class {
       return true;
     }
     if (schedule.recurrence) {
-      log17.error("calendar.invalid", { projectId: schedule.projectId, kind: schedule.kind });
+      log18.error("calendar.invalid", { projectId: schedule.projectId, kind: schedule.kind });
       return false;
     }
     const { id: scheduleId, projectId, cronExpr, timezone } = schedule;
     const kind = schedule.kind;
     if (!cron.validate(cronExpr)) {
-      log17.error("cron.invalid", { projectId, kind, cronExpr });
+      log18.error("cron.invalid", { projectId, kind, cronExpr });
       return false;
     }
     const key = taskKey(projectId, kind);
@@ -13547,7 +14049,7 @@ var Scheduler = class {
       });
     }
     const label = schedule.preset ?? cronExpr;
-    log17.info("cron.registered", { projectId, kind, schedule: label, timezone });
+    log18.info("cron.registered", { projectId, kind, schedule: label, timezone });
     return true;
   }
   /** Calendar schedules are checked at most once a minute so long intervals
@@ -13577,7 +14079,7 @@ var Scheduler = class {
     };
     const tick = () => {
       if (stopped) return;
-      const current = this.db.select().from(schedules).where(eq20(schedules.id, scheduleId)).get();
+      const current = this.db.select().from(schedules).where(eq21(schedules.id, scheduleId)).get();
       if (!current || !current.enabled || !scheduleRecurrence(current)) {
         this.remove(projectId, kind);
         return;
@@ -13595,7 +14097,7 @@ var Scheduler = class {
           this.triggerRun(scheduleId, projectId, kind);
         }
       }
-      arm(this.db.select({ nextRunAt: schedules.nextRunAt }).from(schedules).where(eq20(schedules.id, scheduleId)).get()?.nextRunAt);
+      arm(this.db.select({ nextRunAt: schedules.nextRunAt }).from(schedules).where(eq21(schedules.id, scheduleId)).get()?.nextRunAt);
     };
     this.tasks.set(key, task);
     let registeredNextRunAt = schedule.nextRunAt;
@@ -13605,12 +14107,12 @@ var Scheduler = class {
     }
     if (options.preserveNextRunAt) arm(registeredNextRunAt);
     else timer = setTimeout(tick, 0);
-    log17.info("calendar.registered", { projectId, kind, recurrence, timezone });
+    log18.info("calendar.registered", { projectId, kind, recurrence, timezone });
   }
   /** Atomically advance a due callback-only calendar occurrence before dispatch. */
   claimCalendarOccurrence(schedule, dueAt, now) {
     return this.db.transaction((tx) => {
-      const current = tx.select().from(schedules).where(eq20(schedules.id, schedule.id)).get();
+      const current = tx.select().from(schedules).where(eq21(schedules.id, schedule.id)).get();
       if (!current || !current.enabled || current.updatedAt !== schedule.updatedAt || current.nextRunAt !== dueAt) return false;
       const recurrence = scheduleRecurrence(current);
       if (!recurrence) return false;
@@ -13619,11 +14121,11 @@ var Scheduler = class {
       const result = tx.update(schedules).set({
         nextRunAt,
         updatedAt: nextScheduleUpdatedAt(current.updatedAt)
-      }).where(and17(
-        eq20(schedules.id, current.id),
-        eq20(schedules.enabled, true),
-        eq20(schedules.nextRunAt, dueAt),
-        eq20(schedules.updatedAt, schedule.updatedAt)
+      }).where(and18(
+        eq21(schedules.id, current.id),
+        eq21(schedules.enabled, true),
+        eq21(schedules.nextRunAt, dueAt),
+        eq21(schedules.updatedAt, schedule.updatedAt)
       )).run();
       return result.changes === 1;
     });
@@ -13645,15 +14147,15 @@ var Scheduler = class {
   fireSlot(scheduleId, projectId, kind, claimedOccurrence) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const currentSchedule = this.db.select().from(schedules).where(eq20(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq21(schedules.id, scheduleId)).get();
       if (!currentSchedule || !currentSchedule.enabled) {
-        log17.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
+        log18.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId, kind);
         return slotSkipped(currentSchedule ? OutcomeReasonCodes.NOT_DUE : OutcomeReasonCodes.NOT_FOUND);
       }
       const recurrence = scheduleRecurrence(currentSchedule);
       if (claimedOccurrence && (!recurrence || currentSchedule.nextRunAt !== claimedOccurrence)) {
-        log17.info("calendar.stale-claim", { projectId, scheduleId, kind });
+        log18.info("calendar.stale-claim", { projectId, scheduleId, kind });
         return slotSkipped(OutcomeReasonCodes.NOT_DUE);
       }
       const nextRunAt = nextRunFromSchedule({
@@ -13661,36 +14163,36 @@ var Scheduler = class {
         timezone: currentSchedule.timezone,
         recurrence
       });
-      const project = this.db.select().from(projects).where(eq20(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq21(projects.id, projectId)).get();
       if (!project) {
-        log17.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
+        log18.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
         this.remove(projectId, kind);
         return slotSkipped(OutcomeReasonCodes.NOT_FOUND);
       }
       if (kind === SchedulableRunKinds["traffic-sync"]) {
         const sourceId = currentSchedule.sourceId;
         if (!sourceId) {
-          log17.warn("traffic-sync.missing-source", { scheduleId, projectId });
+          log18.warn("traffic-sync.missing-source", { scheduleId, projectId });
           return slotFailed(OutcomeReasonCodes.VALIDATION);
         }
         if (!this.callbacks.onTrafficSyncRequested) {
-          log17.warn("traffic-sync.no-callback", { scheduleId, projectId, msg: "host did not register onTrafficSyncRequested" });
+          log18.warn("traffic-sync.no-callback", { scheduleId, projectId, msg: "host did not register onTrafficSyncRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
         this.updateScheduleTiming(currentSchedule.id, {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("traffic-sync.triggered", { projectName: project.name, sourceId });
+        log18.info("traffic-sync.triggered", { projectName: project.name, sourceId });
         this.callbacks.onTrafficSyncRequested(project.name, sourceId);
         return SLOT_FIRED;
       }
       if (kind === SchedulableRunKinds["gbp-sync"]) {
         if (!this.callbacks.onGbpSyncRequested) {
-          log17.warn("gbp-sync.no-callback", { scheduleId, projectId, msg: "host did not register onGbpSyncRequested" });
+          log18.warn("gbp-sync.no-callback", { scheduleId, projectId, msg: "host did not register onGbpSyncRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
-        const runId2 = crypto20.randomUUID();
+        const runId2 = crypto21.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -13703,26 +14205,26 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
+        log18.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onGbpSyncRequested(runId2, projectId);
         return SLOT_FIRED;
       }
       if (kind === SchedulableRunKinds["ads-sync"]) {
         if (!this.callbacks.onAdsSyncRequested) {
-          log17.warn("ads-sync.no-callback", { scheduleId, projectId, msg: "host did not register onAdsSyncRequested" });
+          log18.warn("ads-sync.no-callback", { scheduleId, projectId, msg: "host did not register onAdsSyncRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
-        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and17(
-          eq20(runs.projectId, projectId),
-          eq20(runs.kind, RunKinds["ads-sync"]),
+        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and18(
+          eq21(runs.projectId, projectId),
+          eq21(runs.kind, RunKinds["ads-sync"]),
           inArray10(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (activeAdsRun) {
-          log17.info("ads-sync.skipped-active", { projectName: project.name, activeRunId: activeAdsRun.id });
+          log18.info("ads-sync.skipped-active", { projectName: project.name, activeRunId: activeAdsRun.id });
           this.updateScheduleTiming(currentSchedule.id, { nextRunAt });
           return slotSkipped(OutcomeReasonCodes.OPERATION_IN_PROGRESS);
         }
-        const runId2 = crypto20.randomUUID();
+        const runId2 = crypto21.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -13735,22 +14237,22 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
+        log18.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onAdsSyncRequested(runId2, projectId);
         return SLOT_FIRED;
       }
       if (kind === SchedulableRunKinds["seo-sync"]) {
         if (!this.callbacks.onSeoSyncRequested) {
-          log17.warn("seo-sync.no-callback", { scheduleId, projectId, msg: "host did not register onSeoSyncRequested" });
+          log18.warn("seo-sync.no-callback", { scheduleId, projectId, msg: "host did not register onSeoSyncRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
-        const activeSeoRun = this.db.select({ id: runs.id }).from(runs).where(and17(
-          eq20(runs.projectId, projectId),
-          eq20(runs.kind, RunKinds["seo-sync"]),
+        const activeSeoRun = this.db.select({ id: runs.id }).from(runs).where(and18(
+          eq21(runs.projectId, projectId),
+          eq21(runs.kind, RunKinds["seo-sync"]),
           inArray10(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (activeSeoRun) {
-          log17.info("seo-sync.skipped-active", { projectName: project.name, activeRunId: activeSeoRun.id });
+          log18.info("seo-sync.skipped-active", { projectName: project.name, activeRunId: activeSeoRun.id });
           this.updateScheduleTiming(currentSchedule.id, { nextRunAt });
           return slotSkipped(OutcomeReasonCodes.OPERATION_IN_PROGRESS);
         }
@@ -13758,65 +14260,65 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("seo-sync.triggered", { projectName: project.name });
+        log18.info("seo-sync.triggered", { projectName: project.name });
         this.callbacks.onSeoSyncRequested({ scheduleId, projectId, occurrence: now.slice(0, 16) });
         return SLOT_FIRED;
       }
       if (kind === SchedulableRunKinds["data-refresh"]) {
         if (!this.callbacks.onDataRefreshRequested) {
-          log17.warn("data-refresh.no-callback", { scheduleId, projectId, msg: "host did not register onDataRefreshRequested" });
+          log18.warn("data-refresh.no-callback", { scheduleId, projectId, msg: "host did not register onDataRefreshRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
         this.updateScheduleTiming(currentSchedule.id, {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("data-refresh.triggered", { projectName: project.name });
+        log18.info("data-refresh.triggered", { projectName: project.name });
         this.callbacks.onDataRefreshRequested(project.name);
         return SLOT_FIRED;
       }
       if (kind === SchedulableRunKinds.doctor) {
         if (!this.callbacks.onDoctorRequested) {
-          log17.warn("doctor.no-callback", { scheduleId, projectId, msg: "host did not register onDoctorRequested" });
+          log18.warn("doctor.no-callback", { scheduleId, projectId, msg: "host did not register onDoctorRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
         this.updateScheduleTiming(currentSchedule.id, {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("doctor.triggered", { projectName: project.name });
+        log18.info("doctor.triggered", { projectName: project.name });
         this.callbacks.onDoctorRequested(project.name);
         return SLOT_FIRED;
       }
       if (kind === SchedulableRunKinds["backlinks-sync"]) {
         if (!this.callbacks.onBacklinksSyncRequested) {
-          log17.warn("backlinks-sync.no-callback", { scheduleId, projectId, msg: "host did not register onBacklinksSyncRequested" });
+          log18.warn("backlinks-sync.no-callback", { scheduleId, projectId, msg: "host did not register onBacklinksSyncRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
         this.updateScheduleTiming(currentSchedule.id, {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("backlinks-sync.triggered", { projectName: project.name });
+        log18.info("backlinks-sync.triggered", { projectName: project.name });
         this.callbacks.onBacklinksSyncRequested(project.name);
         return SLOT_FIRED;
       }
       if (kind === SchedulableRunKinds["site-audit"]) {
         if (!this.callbacks.onSiteAuditRequested) {
-          log17.warn("site-audit.no-callback", { scheduleId, projectId, msg: "host did not register onSiteAuditRequested" });
+          log18.warn("site-audit.no-callback", { scheduleId, projectId, msg: "host did not register onSiteAuditRequested" });
           return slotFailed(OutcomeReasonCodes.UNSUPPORTED);
         }
-        const active = this.db.select({ id: runs.id }).from(runs).where(and17(
-          eq20(runs.projectId, projectId),
-          eq20(runs.kind, RunKinds["site-audit"]),
+        const active = this.db.select({ id: runs.id }).from(runs).where(and18(
+          eq21(runs.projectId, projectId),
+          eq21(runs.kind, RunKinds["site-audit"]),
           inArray10(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (active) {
-          log17.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
+          log18.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
           this.updateScheduleTiming(currentSchedule.id, { nextRunAt });
           return slotSkipped(OutcomeReasonCodes.OPERATION_IN_PROGRESS);
         }
-        const runId2 = crypto20.randomUUID();
+        const runId2 = crypto21.randomUUID();
         const effectiveRequest = normalizeSiteAuditRunRequest({}, project.siteAuditMaxPages);
         this.db.transaction((tx) => {
           tx.insert(runs).values({
@@ -13839,7 +14341,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt
         });
-        log17.info("site-audit.triggered", { runId: runId2, projectName: project.name });
+        log18.info("site-audit.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onSiteAuditRequested(runId2, projectId, { maxPages: effectiveRequest.maxPages });
         return SLOT_FIRED;
       }
@@ -13848,7 +14350,7 @@ var Scheduler = class {
       if (project.defaultLocation) {
         const loc = projectLocations.find((l) => l.label === project.defaultLocation);
         if (!loc) {
-          log17.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
+          log18.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
           return slotFailed(OutcomeReasonCodes.VALIDATION);
         }
         resolvedLocation = loc;
@@ -13857,7 +14359,7 @@ var Scheduler = class {
       const scheduleProviders = currentSchedule.providers;
       const providers = scheduleProviders.length > 0 ? scheduleProviders : void 0;
       if (claimedOccurrence && recurrence && !nextRunAt) {
-        log17.error("calendar.invalid", { projectId, kind, scheduleId });
+        log18.error("calendar.invalid", { projectId, kind, scheduleId });
         return slotFailed(OutcomeReasonCodes.VALIDATION);
       }
       const queueResult = queueRunIfProjectIdle(this.db, {
@@ -13885,11 +14387,11 @@ var Scheduler = class {
       });
       if (queueResult.conflict) {
         if (queueResult.scheduleClaimed === false) {
-          log17.info("calendar.skipped-claimed", { projectName: project.name, scheduleId: currentSchedule.id });
+          log18.info("calendar.skipped-claimed", { projectName: project.name, scheduleId: currentSchedule.id });
           return slotSkipped(OutcomeReasonCodes.NOT_DUE);
         }
         const batchPending = hasOutstandingProviderBatch(this.db, queueResult.activeRunId);
-        log17.info("run.skipped-active", {
+        log18.info("run.skipped-active", {
           projectName: project.name,
           activeRunId: queueResult.activeRunId,
           ...batchPending ? { reason: "batch-pending" } : {}
@@ -13898,7 +14400,7 @@ var Scheduler = class {
         return slotSkipped(OutcomeReasonCodes.OPERATION_IN_PROGRESS);
       }
       if (queueResult.refused) {
-        log17.warn("run.skipped-providers-failing", {
+        log18.warn("run.skipped-providers-failing", {
           projectName: project.name,
           scheduleId: currentSchedule.id,
           ...queueResult.refused
@@ -13917,7 +14419,7 @@ var Scheduler = class {
       const runId = queueResult.runId;
       for (const [provider, reason] of Object.entries(queueResult.dispatch.ineligible)) {
         if (!reason) continue;
-        log17.warn("run.dispatch-sync-fallback", {
+        log18.warn("run.dispatch-sync-fallback", {
           runId,
           projectName: project.name,
           provider,
@@ -13931,7 +14433,7 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt
       });
-      log17.info("run.triggered", {
+      log18.info("run.triggered", {
         runId,
         projectName: project.name,
         providers: providers ?? "all",
@@ -13940,14 +14442,14 @@ var Scheduler = class {
       this.callbacks.onRunCreated(runId, projectId, providers, resolvedLocation);
       return SLOT_FIRED;
     } catch (err) {
-      log17.error("trigger.error", { scheduleId, projectId, kind, error: describeError(err) });
+      log18.error("trigger.error", { scheduleId, projectId, kind, error: describeError(err) });
       return { status: OutcomeStatuses.failed, ...outcomeFailure(err) };
     }
   }
 };
 
 // src/site-liveness-loop.ts
-var log18 = createLogger("SiteLiveness");
+var log19 = createLogger("SiteLiveness");
 var SITE_LIVENESS_INTERVAL_MS = 10 * 6e4;
 async function runSiteLivenessPass(deps) {
   const now = deps.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -13964,10 +14466,10 @@ async function runSiteLivenessPass(deps) {
       const event = await deps.notify(project.id, { check, checkedAt: now() });
       if (event) {
         events += 1;
-        log18.info("site-liveness.notified", { projectName: project.name, event, code: check.code });
+        log19.info("site-liveness.notified", { projectName: project.name, event, code: check.code });
       }
     } catch (err) {
-      log18.warn("site-liveness.project-failed", { projectName: project.name, err: String(err) });
+      log19.warn("site-liveness.project-failed", { projectName: project.name, err: String(err) });
       if (failed === 0) firstFailure = err;
       failed += 1;
     }
@@ -13999,14 +14501,14 @@ function startSiteLivenessLoop(deps, intervalMs = SITE_LIVENESS_INTERVAL_MS) {
   };
   const timer = setInterval(() => {
     if (running) {
-      log18.warn("site-liveness.pass-still-running", { intervalMs });
+      log19.warn("site-liveness.pass-still-running", { intervalMs });
       report({ status: OutcomeStatuses.skipped, reasonCode: OutcomeReasonCodes.OPERATION_IN_PROGRESS });
       return;
     }
     running = true;
     const elapsed = startOutcomeTimer();
     void runSiteLivenessPass(deps).then((result) => report({ ...livenessOutcome(result), durationBucket: elapsed() })).catch((err) => {
-      log18.warn("site-liveness.pass-failed", { err: String(err) });
+      log19.warn("site-liveness.pass-failed", { err: String(err) });
       report({ status: OutcomeStatuses.failed, ...outcomeFailure(err), durationBucket: elapsed() });
     }).finally(() => {
       running = false;
@@ -14018,8 +14520,8 @@ function startSiteLivenessLoop(deps, intervalMs = SITE_LIVENESS_INTERVAL_MS) {
 
 // src/review-webhook-delivery.ts
 import { createHash as createHash7 } from "crypto";
-import { and as and18, asc as asc4, eq as eq21, isNull as isNull3, lte as lte2, or } from "drizzle-orm";
-var log19 = createLogger("ReviewDelivery");
+import { and as and19, asc as asc4, eq as eq22, isNull as isNull3, lte as lte2, or } from "drizzle-orm";
+var log20 = createLogger("ReviewDelivery");
 var hash = (value) => createHash7("sha256").update(JSON.stringify(value)).digest("hex");
 var REVIEW_DELIVERY_MAX_ATTEMPTS = 10;
 var REVIEW_CHAT_SENDS_PER_PASS = 3;
@@ -14046,20 +14548,20 @@ function reviewEventId(projectId, review) {
 function reviewEventRefusal(db, projectId, payload, notification, targetDigest, now) {
   if (!notification?.enabled || !notification.config.events.includes("review.negative")) return "destination_disabled";
   if (targetDigest !== void 0 && hash(notification.config.url) !== targetDigest) return "destination_changed";
-  const project = db.select().from(projects).where(eq21(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq22(projects.id, projectId)).get();
   if (!project || project.name !== payload.project.name || project.canonicalDomain !== payload.project.canonicalDomain) return "project_changed";
   const review = payload.reviews[0];
-  const location = db.select().from(gbpLocations).where(and18(
-    eq21(gbpLocations.projectId, projectId),
-    eq21(gbpLocations.locationName, review.location.name),
-    eq21(gbpLocations.selected, true)
+  const location = db.select().from(gbpLocations).where(and19(
+    eq22(gbpLocations.projectId, projectId),
+    eq22(gbpLocations.locationName, review.location.name),
+    eq22(gbpLocations.selected, true)
   )).get();
   if (!location || review.origin === "gbp" && !review.reviewName.startsWith(`${location.accountName}/${location.locationName}/reviews/`)) return "location_removed_or_deselected";
-  const current = db.select().from(gbpReviews).where(and18(
-    eq21(gbpReviews.projectId, projectId),
-    eq21(gbpReviews.origin, review.origin),
-    eq21(gbpReviews.reviewName, review.reviewName),
-    eq21(gbpReviews.locationName, review.location.name)
+  const current = db.select().from(gbpReviews).where(and19(
+    eq22(gbpReviews.projectId, projectId),
+    eq22(gbpReviews.origin, review.origin),
+    eq22(gbpReviews.reviewName, review.reviewName),
+    eq22(gbpReviews.locationName, review.location.name)
   )).get();
   if (!current) return "review_removed";
   if (!isWithinAlertWindow(review.updateTime, now) || !isWithinAlertWindow(current.updateTime, now)) return "review_expired";
@@ -14067,10 +14569,10 @@ function reviewEventRefusal(db, projectId, payload, notification, targetDigest,
   if (!isNegativeReviewRating(current.starRating, threshold) || !isNegativeReviewRating(review.starRating, threshold)) return "review_no_longer_negative";
   if (["baseline", "skipped", "suppressed", "stale", "none"].includes(current.alertState)) return "review_suppressed";
   if (review.origin === "places") {
-    const v4HasWorked = db.select({ id: gbpReviewRatings.id }).from(gbpReviewRatings).where(and18(
-      eq21(gbpReviewRatings.projectId, projectId),
-      eq21(gbpReviewRatings.locationName, review.location.name),
-      eq21(gbpReviewRatings.origin, "gbp")
+    const v4HasWorked = db.select({ id: gbpReviewRatings.id }).from(gbpReviewRatings).where(and19(
+      eq22(gbpReviewRatings.projectId, projectId),
+      eq22(gbpReviewRatings.locationName, review.location.name),
+      eq22(gbpReviewRatings.origin, "gbp")
     )).get() !== void 0;
     if (businessProfileReviewsCover(location.reviewsAccess, v4HasWorked)) return "review_origin_superseded";
   }
@@ -14078,9 +14580,9 @@ function reviewEventRefusal(db, projectId, payload, notification, targetDigest,
 }
 function cancelReviewDelivery(db, id, reason) {
   db.transaction((tx) => {
-    const canceled = tx.update(reviewWebhookDeliveries).set({ state: ReviewDeliveryStates.Canceled, retryAt: null }).where(and18(
-      eq21(reviewWebhookDeliveries.id, id),
-      eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending)
+    const canceled = tx.update(reviewWebhookDeliveries).set({ state: ReviewDeliveryStates.Canceled, retryAt: null }).where(and19(
+      eq22(reviewWebhookDeliveries.id, id),
+      eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending)
     )).returning({ projectId: reviewWebhookDeliveries.projectId, eventId: reviewWebhookDeliveries.eventId, notificationId: reviewWebhookDeliveries.notificationId, targetDigest: reviewWebhookDeliveries.targetDigest }).get();
     if (canceled) writeAuditLog(tx, {
       projectId: canceled.projectId,
@@ -14096,10 +14598,10 @@ function deferReviewDelivery(db, saved, now) {
   if (saved.state !== ReviewDeliveryStates.Pending && saved.state !== ReviewDeliveryStates.Attempting) return;
   const waited = now - Date.parse(saved.createdAt);
   const delay = Math.min(Math.max(RETRY_BASE_MS, Number.isFinite(waited) ? waited / 4 : RETRY_BASE_MS), RETRY_MAX_MS);
-  db.update(reviewWebhookDeliveries).set({ retryAt: new Date(now + delay).toISOString() }).where(and18(
-    eq21(reviewWebhookDeliveries.id, saved.id),
-    eq21(reviewWebhookDeliveries.state, saved.state),
-    eq21(reviewWebhookDeliveries.attempts, saved.attempts)
+  db.update(reviewWebhookDeliveries).set({ retryAt: new Date(now + delay).toISOString() }).where(and19(
+    eq22(reviewWebhookDeliveries.id, saved.id),
+    eq22(reviewWebhookDeliveries.state, saved.state),
+    eq22(reviewWebhookDeliveries.attempts, saved.attempts)
   )).run();
 }
 function auditUndelivered(db, saved, outcome) {
@@ -14116,8 +14618,8 @@ function dueReviewDeliveryProjects(db, now) {
   const at = new Date(now).toISOString();
   const staleAttempt = new Date(now - 6e4).toISOString();
   return db.selectDistinct({ projectId: reviewWebhookDeliveries.projectId }).from(reviewWebhookDeliveries).where(or(
-    and18(eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending), or(isNull3(reviewWebhookDeliveries.retryAt), lte2(reviewWebhookDeliveries.retryAt, at))),
-    and18(eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting), lte2(reviewWebhookDeliveries.attemptedAt, staleAttempt))
+    and19(eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending), or(isNull3(reviewWebhookDeliveries.retryAt), lte2(reviewWebhookDeliveries.retryAt, at))),
+    and19(eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting), lte2(reviewWebhookDeliveries.attemptedAt, staleAttempt))
   )).all().map((row) => row.projectId);
 }
 function startReviewDeliveryLoop(drain, intervalMs = REVIEW_DELIVERY_INTERVAL_MS) {
@@ -14126,7 +14628,7 @@ function startReviewDeliveryLoop(drain, intervalMs = REVIEW_DELIVERY_INTERVAL_MS
     if (running) return;
     running = true;
     void drain().catch((err) => {
-      log19.warn("review-delivery.drain-failed", { error: describeError(err) });
+      log20.warn("review-delivery.drain-failed", { error: describeError(err) });
     }).finally(() => {
       running = false;
     });
@@ -14138,12 +14640,12 @@ async function drainReviewDeliveries(options) {
   const now = (options.now ?? Date.now)();
   const at = new Date(now).toISOString();
   const staleAttempt = new Date(now - 6e4).toISOString();
-  const ready = options.db.select().from(reviewWebhookDeliveries).where(and18(
-    eq21(reviewWebhookDeliveries.projectId, options.projectId),
+  const ready = options.db.select().from(reviewWebhookDeliveries).where(and19(
+    eq22(reviewWebhookDeliveries.projectId, options.projectId),
     or(isNull3(reviewWebhookDeliveries.retryAt), lte2(reviewWebhookDeliveries.retryAt, at)),
     or(
-      eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending),
-      and18(eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting), lte2(reviewWebhookDeliveries.attemptedAt, staleAttempt))
+      eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending),
+      and19(eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting), lte2(reviewWebhookDeliveries.attemptedAt, staleAttempt))
     )
   )).orderBy(asc4(reviewWebhookDeliveries.retryAt), asc4(reviewWebhookDeliveries.attemptedAt), asc4(reviewWebhookDeliveries.createdAt), asc4(reviewWebhookDeliveries.id)).limit(100).all();
   let delivered = 0;
@@ -14167,15 +14669,15 @@ async function deliverReviewEvent(options) {
   if (!payload.eventId || !/^evt_[a-f0-9]{64}$/u.test(payload.eventId) || payload.reviews.length !== 1)
     return false;
   const notification = db.select().from(notifications).where(
-    and18(
-      eq21(notifications.id, notificationId),
-      eq21(notifications.projectId, projectId)
+    and19(
+      eq22(notifications.id, notificationId),
+      eq22(notifications.projectId, projectId)
     )
   ).get();
   const id = hash([projectId, notificationId, payload.eventId]);
   const now = options.now ?? Date.now;
   const at = new Date(now()).toISOString();
-  let saved = db.select().from(reviewWebhookDeliveries).where(eq21(reviewWebhookDeliveries.id, id)).get();
+  let saved = db.select().from(reviewWebhookDeliveries).where(eq22(reviewWebhookDeliveries.id, id)).get();
   const event = saved?.payload ?? payload;
   const refusal = reviewEventRefusal(db, projectId, event, notification, saved?.targetDigest, new Date(now()));
   if (refusal) {
@@ -14194,7 +14696,7 @@ async function deliverReviewEvent(options) {
     payload,
     createdAt: at
   }).onConflictDoNothing().run();
-  saved = db.select().from(reviewWebhookDeliveries).where(eq21(reviewWebhookDeliveries.id, id)).get();
+  saved = db.select().from(reviewWebhookDeliveries).where(eq22(reviewWebhookDeliveries.id, id)).get();
   if (!saved || saved.targetDigest !== targetDigest) return false;
   if (saved.state === ReviewDeliveryStates.Sent) return true;
   if (saved.state === ReviewDeliveryStates.Uncertain || saved.state === ReviewDeliveryStates.Canceled) return false;
@@ -14209,17 +14711,17 @@ async function deliverReviewEvent(options) {
       return false;
     const state2 = destination.signed ? ReviewDeliveryStates.Pending : ReviewDeliveryStates.Uncertain;
     const moved = db.update(reviewWebhookDeliveries).set({ state: state2 }).where(
-      and18(
-        eq21(reviewWebhookDeliveries.id, id),
-        eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting),
-        eq21(reviewWebhookDeliveries.attempts, saved.attempts),
-        eq21(reviewWebhookDeliveries.attemptedAt, saved.attemptedAt)
+      and19(
+        eq22(reviewWebhookDeliveries.id, id),
+        eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting),
+        eq22(reviewWebhookDeliveries.attempts, saved.attempts),
+        eq22(reviewWebhookDeliveries.attemptedAt, saved.attemptedAt)
       )
     ).returning({ id: reviewWebhookDeliveries.id }).get();
     if (moved && state2 === ReviewDeliveryStates.Uncertain) {
       auditUndelivered(db, saved, { state: state2, reason: "interrupted_attempt", attempts: saved.attempts });
     }
-    saved = db.select().from(reviewWebhookDeliveries).where(eq21(reviewWebhookDeliveries.id, id)).get();
+    saved = db.select().from(reviewWebhookDeliveries).where(eq22(reviewWebhookDeliveries.id, id)).get();
     if (!saved || saved.state !== ReviewDeliveryStates.Pending) return false;
   }
   if (saved.retryAt && Date.parse(saved.retryAt) > now()) return false;
@@ -14241,9 +14743,9 @@ async function deliverReviewEvent(options) {
     return false;
   }
   const latest = db.select().from(notifications).where(
-    and18(
-      eq21(notifications.id, notificationId),
-      eq21(notifications.projectId, projectId)
+    and19(
+      eq22(notifications.id, notificationId),
+      eq22(notifications.projectId, projectId)
     )
   ).get();
   const latestRefusal = reviewEventRefusal(db, projectId, saved.payload, latest, targetDigest, new Date(now()));
@@ -14256,10 +14758,10 @@ async function deliverReviewEvent(options) {
     attempts: saved.attempts + 1,
     attemptedAt: new Date(now()).toISOString()
   }).where(
-    and18(
-      eq21(reviewWebhookDeliveries.id, id),
-      eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending),
-      eq21(reviewWebhookDeliveries.attempts, saved.attempts)
+    and19(
+      eq22(reviewWebhookDeliveries.id, id),
+      eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Pending),
+      eq22(reviewWebhookDeliveries.attempts, saved.attempts)
     )
   ).returning({ id: reviewWebhookDeliveries.id }).get();
   if (!claimed) return false;
@@ -14286,10 +14788,10 @@ async function deliverReviewEvent(options) {
     deliveredAt: sent ? new Date(now()).toISOString() : null,
     retryAt: state === ReviewDeliveryStates.Pending ? new Date(now() + retryDelayMs(attempts, result.retryAfterSeconds)).toISOString() : null
   }).where(
-    and18(
-      eq21(reviewWebhookDeliveries.id, id),
-      eq21(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting),
-      eq21(reviewWebhookDeliveries.attempts, attempts)
+    and19(
+      eq22(reviewWebhookDeliveries.id, id),
+      eq22(reviewWebhookDeliveries.state, ReviewDeliveryStates.Attempting),
+      eq22(reviewWebhookDeliveries.attempts, attempts)
     )
   ).run();
   if (state === ReviewDeliveryStates.Uncertain || state === ReviewDeliveryStates.Failed) {
@@ -14301,8 +14803,8 @@ async function deliverReviewEvent(options) {
 }
 
 // src/unrecognized-agent-alerts.ts
-import { and as and19, desc as desc8, eq as eq22, gte as gte3, sql as sql9 } from "drizzle-orm";
-var log20 = createLogger("UnrecognizedAgentAlerts");
+import { and as and20, desc as desc8, eq as eq23, gte as gte3, sql as sql10 } from "drizzle-orm";
+var log21 = createLogger("UnrecognizedAgentAlerts");
 var UNRECOGNIZED_AGENT_ALERT_WINDOW_MS = 7 * 864e5;
 var UNRECOGNIZED_AGENT_ALERT_MIN_HITS = 3;
 var UNRECOGNIZED_AGENT_ALERT_INTERVAL_MS = 15 * 6e4;
@@ -14317,13 +14819,13 @@ function projectsWithRecentUnrecognizedAgents(db, now) {
   return db.selectDistinct({ projectId: unrecognizedAgentEventsHourly.projectId }).from(unrecognizedAgentEventsHourly).where(gte3(unrecognizedAgentEventsHourly.tsHour, since)).all().map((row) => row.projectId);
 }
 function undecidedUnrecognizedAgents(db, projectId, now) {
-  const decided = new Set(db.select({ agentName: unrecognizedAgentNotifyState.agentName }).from(unrecognizedAgentNotifyState).where(eq22(unrecognizedAgentNotifyState.projectId, projectId)).all().map((row) => row.agentName));
+  const decided = new Set(db.select({ agentName: unrecognizedAgentNotifyState.agentName }).from(unrecognizedAgentNotifyState).where(eq23(unrecognizedAgentNotifyState.projectId, projectId)).all().map((row) => row.agentName));
   const totals = db.select({
     name: unrecognizedAgentEventsHourly.agentName,
-    hits: sql9`SUM(${unrecognizedAgentEventsHourly.hits})`,
-    firstSeenAt: sql9`MIN(${unrecognizedAgentEventsHourly.tsHour})`,
-    lastSeenAt: sql9`MAX(${unrecognizedAgentEventsHourly.tsHour})`
-  }).from(unrecognizedAgentEventsHourly).where(eq22(unrecognizedAgentEventsHourly.projectId, projectId)).groupBy(unrecognizedAgentEventsHourly.agentName).all();
+    hits: sql10`SUM(${unrecognizedAgentEventsHourly.hits})`,
+    firstSeenAt: sql10`MIN(${unrecognizedAgentEventsHourly.tsHour})`,
+    lastSeenAt: sql10`MAX(${unrecognizedAgentEventsHourly.tsHour})`
+  }).from(unrecognizedAgentEventsHourly).where(eq23(unrecognizedAgentEventsHourly.projectId, projectId)).groupBy(unrecognizedAgentEventsHourly.agentName).all();
   const windowStart = new Date(now - UNRECOGNIZED_AGENT_ALERT_WINDOW_MS).toISOString();
   const recordingStart = totals.reduce((earliest, total) => earliest === null || total.firstSeenAt < earliest ? total.firstSeenAt : earliest, null);
   const baselineEnd = recordingStart === null ? null : new Date(Date.parse(recordingStart) + UNRECOGNIZED_AGENT_ALERT_WINDOW_MS).toISOString();
@@ -14341,7 +14843,7 @@ function undecidedUnrecognizedAgents(db, projectId, now) {
       continue;
     }
     if (Number(total.hits) < UNRECOGNIZED_AGENT_ALERT_MIN_HITS) continue;
-    const latest = db.select({ sampledUserAgent: unrecognizedAgentEventsHourly.sampledUserAgent, sampledPath: unrecognizedAgentEventsHourly.sampledPath }).from(unrecognizedAgentEventsHourly).where(and19(eq22(unrecognizedAgentEventsHourly.projectId, projectId), eq22(unrecognizedAgentEventsHourly.agentName, total.name))).orderBy(desc8(unrecognizedAgentEventsHourly.tsHour)).limit(1).get();
+    const latest = db.select({ sampledUserAgent: unrecognizedAgentEventsHourly.sampledUserAgent, sampledPath: unrecognizedAgentEventsHourly.sampledPath }).from(unrecognizedAgentEventsHourly).where(and20(eq23(unrecognizedAgentEventsHourly.projectId, projectId), eq23(unrecognizedAgentEventsHourly.agentName, total.name))).orderBy(desc8(unrecognizedAgentEventsHourly.tsHour)).limit(1).get();
     due.push({
       name: total.name,
       hits: Number(total.hits),
@@ -14366,7 +14868,7 @@ function startUnrecognizedAgentAlertLoop(dispatch, intervalMs = UNRECOGNIZED_AGE
     if (running) return;
     running = true;
     void dispatch().catch((err) => {
-      log20.warn("unrecognized-agent-alerts.dispatch-failed", { error: describeError(err) });
+      log21.warn("unrecognized-agent-alerts.dispatch-failed", { error: describeError(err) });
     }).finally(() => {
       running = false;
     });
@@ -14376,8 +14878,8 @@ function startUnrecognizedAgentAlertLoop(dispatch, intervalMs = UNRECOGNIZED_AGE
 }
 
 // src/provider-batch-poller.ts
-import { and as and20, eq as eq23, inArray as inArray11, isNotNull as isNotNull3, isNull as isNull4, notExists as notExists2, sql as sql10 } from "drizzle-orm";
-var log21 = createLogger("ProviderBatchPoller");
+import { and as and21, eq as eq24, inArray as inArray11, isNotNull as isNotNull3, isNull as isNull4, notExists as notExists2, sql as sql11 } from "drizzle-orm";
+var log22 = createLogger("ProviderBatchPoller");
 var PROVIDER_BATCH_POLL_INITIAL_MS = 3e4;
 var PROVIDER_BATCH_POLL_MAX_MS = 10 * 6e4;
 var PROVIDER_BATCH_CANCEL_GRACE_MS = 60 * 6e4;
@@ -14401,7 +14903,7 @@ var ProviderBatchPoller = class {
       try {
         if (await this.advance(row)) settledRuns.set(row.runId, row.projectId);
       } catch (err) {
-        log21.warn("batch.advance-failed", { batchId: row.id, runId: row.runId, provider: row.provider, error: describeError(err) });
+        log22.warn("batch.advance-failed", { batchId: row.id, runId: row.runId, provider: row.provider, error: describeError(err) });
         this.reschedule(row.id, null);
       }
     }
@@ -14410,7 +14912,7 @@ var ProviderBatchPoller = class {
       try {
         this.deps.runner.finalizeBatchRun(runId, projectId);
       } catch (err) {
-        log21.warn("batch.finalize-failed", { runId, error: describeError(err) });
+        log22.warn("batch.finalize-failed", { runId, error: describeError(err) });
       }
     }
   }
@@ -14419,7 +14921,7 @@ var ProviderBatchPoller = class {
    * outstanding (ingested or cancelled), so its run may now finalize.
    */
   async advance(row) {
-    const runStatus = this.deps.db.select({ status: runs.status }).from(runs).where(eq23(runs.id, row.runId)).get()?.status;
+    const runStatus = this.deps.db.select({ status: runs.status }).from(runs).where(eq24(runs.id, row.runId)).get()?.status;
     if (runStatus !== RunStatuses.running) {
       await this.deps.runner.abandonProviderBatches([row.id], "Cancelled because its run is no longer running.");
       this.schedule.delete(row.id);
@@ -14436,15 +14938,15 @@ var ProviderBatchPoller = class {
         status = poll.status;
         if (poll.status === "ended") {
           const endedAt = poll.endedAt ?? new Date(this.now()).toISOString();
-          const ended = this.deps.db.update(providerBatches).set({ status: ProviderBatchStatuses.ended, endedAt, resultsExpireAt: poll.resultsExpireAt ?? null, updatedAt: endedAt }).where(and20(eq23(providerBatches.id, row.id), eq23(providerBatches.status, ProviderBatchStatuses.submitted))).run().changes === 1;
+          const ended = this.deps.db.update(providerBatches).set({ status: ProviderBatchStatuses.ended, endedAt, resultsExpireAt: poll.resultsExpireAt ?? null, updatedAt: endedAt }).where(and21(eq24(providerBatches.id, row.id), eq24(providerBatches.status, ProviderBatchStatuses.submitted))).run().changes === 1;
           this.schedule.delete(row.id);
           return ended ? this.ingest({ ...row, status: ProviderBatchStatuses.ended, resultsExpireAt: poll.resultsExpireAt ?? null }) : false;
         }
       } catch (err) {
-        log21.warn("batch.poll-failed", { batchId: row.id, runId: row.runId, provider: row.provider, error: describeError(err) });
+        log22.warn("batch.poll-failed", { batchId: row.id, runId: row.runId, provider: row.provider, error: describeError(err) });
       }
     } else {
-      log21.warn("batch.poll-unavailable", { batchId: row.id, runId: row.runId, provider: row.provider });
+      log22.warn("batch.poll-unavailable", { batchId: row.id, runId: row.runId, provider: row.provider });
     }
     this.reschedule(row.id, status);
     return this.enforceDeadline(row, registered);
@@ -14460,18 +14962,18 @@ var ProviderBatchPoller = class {
     const at = new Date(now).toISOString();
     if (row.cancelRequestedAt === null) {
       if (now < Date.parse(row.deadlineAt)) return false;
-      const claimed = this.deps.db.update(providerBatches).set({ cancelRequestedAt: at, updatedAt: at }).where(and20(
-        eq23(providerBatches.id, row.id),
-        eq23(providerBatches.status, ProviderBatchStatuses.submitted),
+      const claimed = this.deps.db.update(providerBatches).set({ cancelRequestedAt: at, updatedAt: at }).where(and21(
+        eq24(providerBatches.id, row.id),
+        eq24(providerBatches.status, ProviderBatchStatuses.submitted),
         isNull4(providerBatches.cancelRequestedAt)
       )).run().changes === 1;
       if (!claimed) return false;
-      log21.warn("batch.deadline-passed", { batchId: row.id, runId: row.runId, provider: row.provider, deadlineAt: row.deadlineAt });
+      log22.warn("batch.deadline-passed", { batchId: row.id, runId: row.runId, provider: row.provider, deadlineAt: row.deadlineAt });
       if (registered?.adapter.batch && row.providerBatchId) {
         try {
           await registered.adapter.batch.cancel(row.providerBatchId, registered.config);
         } catch (err) {
-          log21.warn("batch.cancel-failed", { batchId: row.id, provider: row.provider, error: describeError(err) });
+          log22.warn("batch.cancel-failed", { batchId: row.id, provider: row.provider, error: describeError(err) });
         }
       }
       return false;
@@ -14481,9 +14983,9 @@ var ProviderBatchPoller = class {
       status: ProviderBatchStatuses.cancelled,
       error: `The provider batch did not end within an hour of being cancelled at its deadline; its ${row.requestCount} answer(s) were not recorded.`,
       updatedAt: at
-    }).where(and20(eq23(providerBatches.id, row.id), eq23(providerBatches.status, ProviderBatchStatuses.submitted))).run().changes === 1;
+    }).where(and21(eq24(providerBatches.id, row.id), eq24(providerBatches.status, ProviderBatchStatuses.submitted))).run().changes === 1;
     this.schedule.delete(row.id);
-    if (gaveUp) log21.warn("batch.abandoned-after-deadline", { batchId: row.id, runId: row.runId, provider: row.provider });
+    if (gaveUp) log22.warn("batch.abandoned-after-deadline", { batchId: row.id, runId: row.runId, provider: row.provider });
     return gaveUp;
   }
   async ingest(row) {
@@ -14492,7 +14994,7 @@ var ProviderBatchPoller = class {
       return result.kind !== "skipped";
     } catch (err) {
       const error = describeError(err);
-      log21.warn("batch.ingest-failed", { batchId: row.id, runId: row.runId, provider: row.provider, error });
+      log22.warn("batch.ingest-failed", { batchId: row.id, runId: row.runId, provider: row.provider, error });
       const now = this.now();
       const unreadable = row.resultsExpireAt !== null && now >= Date.parse(row.resultsExpireAt);
       if (unreadable || now >= Date.parse(row.deadlineAt) + PROVIDER_BATCH_CANCEL_GRACE_MS) {
@@ -14521,10 +15023,10 @@ var ProviderBatchPoller = class {
   /** Runs the sweep handed off whose batches have all settled. */
   finalizableRuns() {
     const holding = [ProviderBatchStatuses.submitting, ...OUTSTANDING_PROVIDER_BATCH_STATUSES];
-    return this.deps.db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and20(
-      eq23(runs.status, RunStatuses.running),
+    return this.deps.db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and21(
+      eq24(runs.status, RunStatuses.running),
       isNotNull3(runs.pendingProviderErrors),
-      notExists2(this.deps.db.select({ one: sql10`1` }).from(providerBatches).where(and20(eq23(providerBatches.runId, runs.id), inArray11(providerBatches.status, holding))))
+      notExists2(this.deps.db.select({ one: sql11`1` }).from(providerBatches).where(and21(eq24(providerBatches.runId, runs.id), inArray11(providerBatches.status, holding))))
     )).all();
   }
 };
@@ -14534,7 +15036,7 @@ function startProviderBatchPoller(deps, intervalMs = PROVIDER_BATCH_TICK_MS) {
   const timer = setInterval(() => {
     if (running) return;
     running = true;
-    void poller.tick().catch((err) => log21.warn("batch.pass-failed", { error: describeError(err) })).finally(() => {
+    void poller.tick().catch((err) => log22.warn("batch.pass-failed", { error: describeError(err) })).finally(() => {
       running = false;
     });
   }, intervalMs);
@@ -14543,7 +15045,7 @@ function startProviderBatchPoller(deps, intervalMs = PROVIDER_BATCH_TICK_MS) {
 }
 
 // src/data-refresh.ts
-var log22 = createLogger("DataRefresh");
+var log23 = createLogger("DataRefresh");
 function gaRefreshDays(now = /* @__PURE__ */ new Date()) {
   const [reportMonth] = reportMonthsForDoctor(void 0, now);
   const reach = inclusiveDayCount(`${reportMonth}-01`, now.toISOString().slice(0, 10)) ?? 0;
@@ -14562,6 +15064,7 @@ async function refreshAllIntegrations(client, projectName, now = /* @__PURE__ */
   const integrations = [
     { name: "gsc", kind: RunKinds["gsc-sync"], completion: "queued", run: () => client.gscSync(projectName, {}) },
     { name: "bing", kind: RunKinds["bing-inspect-sitemap"], completion: "queued", run: () => client.bingInspectSitemap(projectName, {}) },
+    { name: "bing-sync", kind: RunKinds["bing-sync"], completion: "queued", run: () => client.bingSync(projectName) },
     { name: "ga", kind: RunKinds["ga-sync"], completion: "synchronous", run: () => client.gaSync(projectName, { days: gaRefreshDays(now) }) },
     { name: "gbp", kind: RunKinds["gbp-sync"], completion: "queued", run: () => client.triggerGbpSync(projectName, {}) },
     // `ads` remains the OpenAI / ChatGPT Ads integration. For scheduled
@@ -14584,15 +15087,15 @@ async function refreshAllIntegrations(client, projectName, now = /* @__PURE__ */
     if (result.status === "rejected") {
       const reason = result.reason;
       const message = describeError(reason);
-      log22.warn("integration.refresh-failed", { projectName, integration, error: message });
+      log23.warn("integration.refresh-failed", { projectName, integration, error: message });
       return;
     }
     switch (completion) {
       case "synchronous":
-        log22.info("integration.refreshed", { projectName, integration });
+        log23.info("integration.refreshed", { projectName, integration });
         return;
       case "queued":
-        log22.info("integration.queued", { projectName, integration, ...queuedRun(result.value) });
+        log23.info("integration.queued", { projectName, integration, ...queuedRun(result.value) });
         return;
       default: {
         const _exhaustive = completion;
@@ -14603,9 +15106,9 @@ async function refreshAllIntegrations(client, projectName, now = /* @__PURE__ */
 }
 
 // src/notifier.ts
-import { eq as eq24, desc as desc9, and as and21, inArray as inArray12, or as or2, isNull as isNull5 } from "drizzle-orm";
-import crypto21 from "crypto";
-var log23 = createLogger("Notifier");
+import { eq as eq25, desc as desc9, and as and22, inArray as inArray12, or as or2, isNull as isNull5 } from "drizzle-orm";
+import crypto22 from "crypto";
+var log24 = createLogger("Notifier");
 var sampleDelivery = createOutcomeSampler({ burst: 20, refillMs: 6e4, now: () => Date.now() });
 function trackWebhookDelivery(input) {
   const sample = sampleDelivery(input.failure ? "failed" : "succeeded");
@@ -14725,26 +15228,26 @@ var Notifier = class {
   }
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId, opts) {
-    log23.info("run.completed", { runId, projectId, origin: opts?.origin ?? "sweep" });
-    const notifs = this.db.select().from(notifications).where(eq24(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    log24.info("run.completed", { runId, projectId, origin: opts?.origin ?? "sweep" });
+    const notifs = this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) {
-      log23.info("notifications.none-enabled", { projectId });
+      log24.info("notifications.none-enabled", { projectId });
       return;
     }
-    log23.info("notifications.found", { projectId, count: notifs.length });
-    const run = this.db.select().from(runs).where(eq24(runs.id, runId)).get();
+    log24.info("notifications.found", { projectId, count: notifs.length });
+    const run = this.db.select().from(runs).where(eq25(runs.id, runId)).get();
     if (!run) {
-      log23.error("run.not-found", { runId, msg: "skipping notification dispatch" });
+      log24.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
-    const project = this.db.select().from(projects).where(eq24(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
     if (!project) {
-      log23.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
+      log24.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
     }
     const transitions = this.computeTransitions(runId, projectId);
     const events = [];
-    log23.info("run.status", { runId: run.id, status: run.status, projectId });
+    log24.info("run.status", { runId: run.id, status: run.status, projectId });
     if ((run.status === "completed" || run.status === "partial") && opts?.origin !== "fill") {
       events.push("run.completed");
     }
@@ -14760,7 +15263,7 @@ var Notifier = class {
       if (!config.url) continue;
       const subscribedEvents = config.events;
       const matchingEvents = events.filter((e) => subscribedEvents.includes(e));
-      log23.info("notification.match", { notificationId: notif.id, subscribedEvents, matchedEvents: matchingEvents });
+      log24.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;
@@ -14816,9 +15319,9 @@ var Notifier = class {
    * than inferred from the absence of a webhook.
    */
   async onHealthChecked(projectId, report) {
-    const project = this.db.select().from(projects).where(eq24(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
     if (!project) {
-      log23.error("project.not-found", { projectId, msg: "skipping health notification" });
+      log24.error("project.not-found", { projectId, msg: "skipping health notification" });
       return null;
     }
     const rank = healthRank;
@@ -14849,7 +15352,7 @@ var Notifier = class {
     const status = noSignal ? "warn" : worst ? worst.status : "ok";
     const code = noSignal ? HEALTH_NO_SIGNAL_CODE : worst?.code ?? "health.ok";
     const summary = noSignal ? `No health check produced a result (${healthChecks.length} skipped) \u2014 health is unknown, not confirmed.` : worst?.summary ?? `All ${graded.length} health check(s) passing.`;
-    const previous = this.db.select().from(doctorHealthState).where(eq24(doctorHealthState.projectId, projectId)).get();
+    const previous = this.db.select().from(doctorHealthState).where(eq25(doctorHealthState.projectId, projectId)).get();
     const previousStatus = previous?.status ?? null;
     const failingSignature = failing.map((c) => `${c.status}:${c.code}`).join(",");
     const failingNow = failing.map((c) => ({ id: c.id, code: c.code, rank: rank(c.status) }));
@@ -14919,7 +15422,7 @@ var Notifier = class {
     const urgentById = new Map(urgentItems.map((item) => [item.id, item]));
     const generalEvent = event;
     const urgentRecord = previous?.urgentNotified ?? null;
-    const enabled = generalEvent || urgentItems.length > 0 || urgentRecord ? this.db.select().from(notifications).where(eq24(notifications.projectId, projectId)).all().filter((n) => n.enabled) : [];
+    const enabled = generalEvent || urgentItems.length > 0 || urgentRecord ? this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled) : [];
     const listedEvents = (notif) => notif.config.events;
     const hasUrl = (notif) => Boolean(notif.config.url);
     const urgentSubscribers = enabled.filter((n) => hasUrl(n) && (listedEvents(n) ?? []).some((e) => URGENT_HEALTH_EVENTS.has(e)));
@@ -14967,7 +15470,7 @@ var Notifier = class {
     if (previous === void 0) {
       this.db.insert(doctorHealthState).values({ ...observation, notifiedAt: null }).run();
     } else {
-      this.db.update(doctorHealthState).set(observation).where(eq24(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set(observation).where(eq25(doctorHealthState.projectId, projectId)).run();
     }
     for (const group of urgentGroups) {
       const { urgentEvent, urgentTold, urgentNew, urgentCleared, urgentNotifs, urgentSettled } = group;
@@ -15011,10 +15514,10 @@ var Notifier = class {
       }
       if (accepted > 0) {
         recordUrgentReceipts(urgentReceipts, group.subscribers, formatUrgentBreaches(urgentSettled) || null);
-        this.db.update(doctorHealthState).set({ urgentNotified: doctorUrgentSummary(urgentReceipts), urgentReceipts }).where(eq24(doctorHealthState.projectId, projectId)).run();
+        this.db.update(doctorHealthState).set({ urgentNotified: doctorUrgentSummary(urgentReceipts), urgentReceipts }).where(eq25(doctorHealthState.projectId, projectId)).run();
       }
       if (urgentNotifs.length > 0) {
-        log23.info("health.urgent-notified", {
+        log24.info("health.urgent-notified", {
           projectId,
           event: urgentEvent,
           codes: urgentEvent === "health.urgent" ? breachCodes(urgentNew) : breachCodes(urgentCleared),
@@ -15025,9 +15528,9 @@ var Notifier = class {
     }
     if (!event) {
       if (clearedThisPass.length > 0 || easedThisPass.length > 0) {
-        log23.info("health.improved", { projectId, status, code, cleared: clearedThisPass, eased: easedThisPass });
+        log24.info("health.improved", { projectId, status, code, cleared: clearedThisPass, eased: easedThisPass });
       } else {
-        log23.info("health.unchanged", { projectId, status, code });
+        log24.info("health.unchanged", { projectId, status, code });
       }
       return null;
     }
@@ -15055,9 +15558,9 @@ var Notifier = class {
       if (await this.sendWebhook(config.url, payload, notif.id, projectId, notif.webhookSecret ?? null)) delivered += 1;
     }
     if (delivered > 0) {
-      this.db.update(doctorHealthState).set({ notifiedAt: now, notifiedSignature: formatBreaches(failingNow), pendingSignature: null }).where(eq24(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set({ notifiedAt: now, notifiedSignature: formatBreaches(failingNow), pendingSignature: null }).where(eq25(doctorHealthState.projectId, projectId)).run();
     }
-    log23.info("health.notified", {
+    log24.info("health.notified", {
       projectId,
       event,
       status,
@@ -15085,12 +15588,12 @@ var Notifier = class {
   async onSiteLivenessChecked(projectId, result) {
     const { check, checkedAt } = result;
     if (check.status !== "ok" && check.status !== "fail") return null;
-    const project = this.db.select().from(projects).where(eq24(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
     if (!project) {
-      log23.error("project.not-found", { projectId, msg: "skipping site liveness notification" });
+      log24.error("project.not-found", { projectId, msg: "skipping site liveness notification" });
       return null;
     }
-    const previous = this.db.select().from(siteLivenessState).where(eq24(siteLivenessState.projectId, projectId)).get();
+    const previous = this.db.select().from(siteLivenessState).where(eq25(siteLivenessState.projectId, projectId)).get();
     const sincePrevious = previous ? Date.parse(checkedAt) - Date.parse(previous.checkedAt) : Number.NaN;
     const countsAsRepeat = Number.isFinite(sincePrevious) && sincePrevious >= SITE_LIVENESS_MIN_PASS_GAP_MS && sincePrevious <= SITE_LIVENESS_MAX_PASS_GAP_MS;
     const failures = check.status === "fail" ? countsAsRepeat ? (previous?.consecutiveFailures ?? 0) + 1 : 1 : 0;
@@ -15100,7 +15603,7 @@ var Notifier = class {
     if (check.status === "ok" && outagePaged) event = "health.recovered";
     const confirmed = check.status === "fail" && failures >= SITE_LIVENESS_FAILURES_TO_PAGE;
     const urgentRecord = previous?.urgentNotifiedAt ?? null;
-    const enabled = event !== null || confirmed || urgentRecord !== null ? this.db.select().from(notifications).where(eq24(notifications.projectId, projectId)).all().filter((n) => n.enabled) : [];
+    const enabled = event !== null || confirmed || urgentRecord !== null ? this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled) : [];
     const listedEvents = (notif) => notif.config.events;
     const hasUrl = (notif) => Boolean(notif.config.url);
     const scoped = enabled.filter((n) => hasUrl(n) && (listedEvents(n) ?? []).some((e) => URGENT_HEALTH_EVENTS.has(e)));
@@ -15133,7 +15636,7 @@ var Notifier = class {
     if (previous === void 0) {
       this.db.insert(siteLivenessState).values(observation).run();
     } else {
-      this.db.update(siteLivenessState).set(observation).where(eq24(siteLivenessState.projectId, projectId)).run();
+      this.db.update(siteLivenessState).set(observation).where(eq25(siteLivenessState.projectId, projectId)).run();
     }
     if (!event && urgentGroups.every((group) => group.urgentEvent === null)) return null;
     const payloadFor = (name) => {
@@ -15169,9 +15672,9 @@ var Notifier = class {
         }
       }
       if (event === "health.degraded" && delivered > 0) {
-        this.db.update(siteLivenessState).set({ notifiedAt: checkedAt }).where(eq24(siteLivenessState.projectId, projectId)).run();
+        this.db.update(siteLivenessState).set({ notifiedAt: checkedAt }).where(eq25(siteLivenessState.projectId, projectId)).run();
       }
-      log23.info("site-liveness.notified", { projectId, event, code: check.code, subscribers: notifs.length, delivered });
+      log24.info("site-liveness.notified", { projectId, event, code: check.code, subscribers: notifs.length, delivered });
     }
     for (const group of urgentGroups) {
       const { urgentEvent, urgentNotifs, generalIds } = group;
@@ -15183,10 +15686,10 @@ var Notifier = class {
       }
       if (accepted > 0) {
         recordUrgentReceipts(urgentReceipts, group.subscribers, group.settled);
-        this.db.update(siteLivenessState).set({ urgentNotifiedAt: siteUrgentSummary(urgentReceipts), urgentReceipts }).where(eq24(siteLivenessState.projectId, projectId)).run();
+        this.db.update(siteLivenessState).set({ urgentNotifiedAt: siteUrgentSummary(urgentReceipts), urgentReceipts }).where(eq25(siteLivenessState.projectId, projectId)).run();
       }
       if (urgentNotifs.length > 0 || generalIds.size > 0) {
-        log23.info("site-liveness.urgent-notified", { projectId, event: urgentEvent, code: check.code, subscribers: urgentNotifs.length + generalIds.size, delivered: accepted });
+        log24.info("site-liveness.urgent-notified", { projectId, event: urgentEvent, code: check.code, subscribers: urgentNotifs.length + generalIds.size, delivered: accepted });
       }
     }
     return event;
@@ -15209,7 +15712,7 @@ var Notifier = class {
    */
   isNewInsightNews(projectId, insight) {
     const key = insightNotifyKey(projectId, insight);
-    const previous = this.db.select().from(insightNotifyState).where(eq24(insightNotifyState.key, key)).get();
+    const previous = this.db.select().from(insightNotifyState).where(eq25(insightNotifyState.key, key)).get();
     if (!previous) return true;
     if (severityRank(insight.severity) > severityRank(previous.severity)) return true;
     const magnitude = insightMagnitude(insight);
@@ -15231,9 +15734,9 @@ var Notifier = class {
       magnitude: insightMagnitude(insight),
       notifiedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const existing = this.db.select().from(insightNotifyState).where(eq24(insightNotifyState.key, key)).get();
+    const existing = this.db.select().from(insightNotifyState).where(eq25(insightNotifyState.key, key)).get();
     if (existing) {
-      this.db.update(insightNotifyState).set(row).where(eq24(insightNotifyState.key, key)).run();
+      this.db.update(insightNotifyState).set(row).where(eq25(insightNotifyState.key, key)).run();
     } else {
       this.db.insert(insightNotifyState).values(row).run();
     }
@@ -15247,11 +15750,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(eq24(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq24(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq25(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq24(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = notif.config;
@@ -15332,9 +15835,9 @@ var Notifier = class {
     return delivered;
   }
   async dispatchQueuedReviewAlerts(projectId) {
-    const pendingReviews = this.db.select().from(gbpReviews).where(and21(eq24(gbpReviews.projectId, projectId), eq24(gbpReviews.alertState, "pending"))).all();
-    const pendingRatings = this.db.select().from(gbpReviewRatings).where(and21(eq24(gbpReviewRatings.projectId, projectId), eq24(gbpReviewRatings.alertState, "pending"))).all();
-    const project = this.db.select().from(projects).where(eq24(projects.id, projectId)).get();
+    const pendingReviews = this.db.select().from(gbpReviews).where(and22(eq25(gbpReviews.projectId, projectId), eq25(gbpReviews.alertState, "pending"))).all();
+    const pendingRatings = this.db.select().from(gbpReviewRatings).where(and22(eq25(gbpReviewRatings.projectId, projectId), eq25(gbpReviewRatings.alertState, "pending"))).all();
+    const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
     if (!project) return { reviews: 0, ratingDrops: 0, delivered: 0 };
     const chatSendsLeft = /* @__PURE__ */ new Map();
     const now = /* @__PURE__ */ new Date();
@@ -15346,10 +15849,10 @@ var Notifier = class {
         displayName: gbpLocations.displayName,
         mapsUri: gbpLocations.mapsUri,
         reviewsAccess: gbpLocations.reviewsAccess
-      }).from(gbpLocations).where(eq24(gbpLocations.projectId, projectId)).all().map((loc) => [loc.locationName, loc])
+      }).from(gbpLocations).where(eq25(gbpLocations.projectId, projectId)).all().map((loc) => [loc.locationName, loc])
     );
     const v4HasWorked = new Set(
-      this.db.select({ locationName: gbpReviewRatings.locationName }).from(gbpReviewRatings).where(and21(eq24(gbpReviewRatings.projectId, projectId), eq24(gbpReviewRatings.origin, "gbp"))).all().map((row) => row.locationName)
+      this.db.select({ locationName: gbpReviewRatings.locationName }).from(gbpReviewRatings).where(and22(eq25(gbpReviewRatings.projectId, projectId), eq25(gbpReviewRatings.origin, "gbp"))).all().map((row) => row.locationName)
     );
     const coveredByBusinessProfile = (locationName) => businessProfileReviewsCover(locations.get(locationName)?.reviewsAccess ?? null, v4HasWorked.has(locationName));
     const locationRef = (locationName) => {
@@ -15378,7 +15881,7 @@ var Notifier = class {
       else if (row.rating === null || row.previousRating === null) setRatingState([row.id], "none");
       else ratingsToSend.push(row);
     }
-    const enabled = this.db.select().from(notifications).where(eq24(notifications.projectId, projectId)).all().filter((n) => n.enabled && n.config.url);
+    const enabled = this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled && n.config.url);
     const subscribedTo = (event) => enabled.filter((n) => (n.config.events ?? []).includes(event));
     const projectRef = { name: project.name, canonicalDomain: project.canonicalDomain };
     const dashboardUrl = `${this.serverUrl}/projects/${project.name}`;
@@ -15432,13 +15935,13 @@ var Notifier = class {
             if (!sent) all = false;
           }
           if (all) {
-            this.db.update(gbpReviews).set({ alertState: "sent", alertStateAt: nowIso }).where(and21(
-              eq24(gbpReviews.id, review.id),
-              eq24(gbpReviews.alertState, "pending"),
-              eq24(gbpReviews.updateTime, review.updateTime),
-              review.alertStateAt === null ? isNull5(gbpReviews.alertStateAt) : eq24(gbpReviews.alertStateAt, review.alertStateAt),
-              review.comment === null ? isNull5(gbpReviews.comment) : eq24(gbpReviews.comment, review.comment),
-              review.starRating === null ? isNull5(gbpReviews.starRating) : eq24(gbpReviews.starRating, review.starRating)
+            this.db.update(gbpReviews).set({ alertState: "sent", alertStateAt: nowIso }).where(and22(
+              eq25(gbpReviews.id, review.id),
+              eq25(gbpReviews.alertState, "pending"),
+              eq25(gbpReviews.updateTime, review.updateTime),
+              review.alertStateAt === null ? isNull5(gbpReviews.alertStateAt) : eq25(gbpReviews.alertStateAt, review.alertStateAt),
+              review.comment === null ? isNull5(gbpReviews.comment) : eq25(gbpReviews.comment, review.comment),
+              review.starRating === null ? isNull5(gbpReviews.starRating) : eq25(gbpReviews.starRating, review.starRating)
             )).run();
           }
         }
@@ -15470,7 +15973,7 @@ var Notifier = class {
         delivered += accepted;
       }
     }
-    log23.info("reviews.dispatched", {
+    log24.info("reviews.dispatched", {
       projectId,
       reviews: reviewsToSend.length,
       ratingDrops: ratingsToSend.length,
@@ -15479,21 +15982,21 @@ var Notifier = class {
     return { reviews: reviewsToSend.length, ratingDrops: ratingsToSend.length, delivered };
   }
   computeTransitions(runId, projectId) {
-    const thisRun = this.db.select().from(runs).where(eq24(runs.id, runId)).get();
+    const thisRun = this.db.select().from(runs).where(eq25(runs.id, runId)).get();
     if (!thisRun) return [];
     const completeness = measurementRunCompleteness(this.db, runId);
     if (completeness.planned && !completeness.complete) {
-      log23.info("transitions.skipped-incomplete", {
+      log24.info("transitions.skipped-incomplete", {
         runId,
         executed: completeness.executed,
         expected: completeness.expected
       });
       return [];
     }
-    const groupSiblings = this.db.select().from(runs).where(and21(
-      eq24(runs.projectId, projectId),
-      eq24(runs.kind, thisRun.kind),
-      eq24(runs.createdAt, thisRun.createdAt),
+    const groupSiblings = this.db.select().from(runs).where(and22(
+      eq25(runs.projectId, projectId),
+      eq25(runs.kind, thisRun.kind),
+      eq25(runs.createdAt, thisRun.createdAt),
       notProbeRun()
     )).all();
     const stillPending = groupSiblings.some((r) => r.status === "queued" || r.status === "running");
@@ -15510,17 +16013,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(eq24(projects.id, projectId)).get();
+    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq25(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(
-      and21(
-        eq24(runs.projectId, projectId),
-        eq24(runs.kind, thisRun.kind),
-        or2(eq24(runs.status, "completed"), eq24(runs.status, "partial")),
+      and22(
+        eq25(runs.projectId, projectId),
+        eq25(runs.kind, thisRun.kind),
+        or2(eq25(runs.status, "completed"), eq25(runs.status, "partial")),
         notProbeRun()
       )
     ).orderBy(desc9(runs.createdAt), desc9(runs.id)).limit(RECENT_FETCH_LIMIT).all();
@@ -15538,7 +16041,7 @@ var Notifier = class {
       provider: querySnapshots.provider,
       location: querySnapshots.location,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(queries, eq24(querySnapshots.queryId, queries.id)).where(inArray12(querySnapshots.runId, currentRunIds)).all();
+    }).from(querySnapshots).leftJoin(queries, eq25(querySnapshots.queryId, queries.id)).where(inArray12(querySnapshots.runId, currentRunIds)).all();
     const previousSnapshots = this.db.select({
       queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
@@ -15589,12 +16092,12 @@ var Notifier = class {
         recordUnrecognizedAgentDecisions(this.db, projectId, baseline, UnrecognizedAgentNotifyStates.baseline, now);
         if (due.length === 0) continue;
         const names = due.map((agent) => agent.name);
-        const subscribed = this.db.select().from(notifications).where(eq24(notifications.projectId, projectId)).all().filter((n) => n.enabled && n.config.url && n.config.events.includes("traffic.agent.discovered"));
+        const subscribed = this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled && n.config.url && n.config.events.includes("traffic.agent.discovered"));
         if (subscribed.length === 0) {
           recordUnrecognizedAgentDecisions(this.db, projectId, names, UnrecognizedAgentNotifyStates.skipped, now);
           continue;
         }
-        const project = this.db.select().from(projects).where(eq24(projects.id, projectId)).get();
+        const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
         if (!project) continue;
         const payload = {
           source: "canonry",
@@ -15625,7 +16128,7 @@ var Notifier = class {
     const targetLabel = redactNotificationUrl(url).urlDisplay;
     const targetCheck = await resolveWebhookTarget(url, { allowLoopback: this.allowLoopbackWebhooks });
     if (!targetCheck.ok) {
-      log23.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
+      log24.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
       this.logDelivery(projectId, notificationId, payload.event, "failed", `SSRF: ${targetCheck.message}`);
       const reasonCode = webhookTargetRefusalReason(targetCheck);
       trackWebhookDelivery({
@@ -15638,7 +16141,7 @@ var Notifier = class {
       });
       return false;
     }
-    log23.info("webhook.send", { event: payload.event, url: targetLabel });
+    log24.info("webhook.send", { event: payload.event, url: targetLabel });
     const maxRetries = 3;
     const delays = [1e3, 4e3, 16e3];
     let lastStatusClass = "network";
@@ -15647,13 +16150,13 @@ var Notifier = class {
       try {
         const response = await deliverWebhook(targetCheck.target, body, signingSecret);
         if (response.status >= 200 && response.status < 300) {
-          log23.info("webhook.delivered", { event: payload.event, url: targetLabel, httpStatus: response.status });
+          log24.info("webhook.delivered", { event: payload.event, url: targetLabel, httpStatus: response.status });
           this.logDelivery(projectId, notificationId, payload.event, "sent", null);
           trackWebhookDelivery({ url, event: payload.event, attempts: attempt + 1, durationBucket: elapsed(), statusClass: "2xx" });
           return true;
         }
         const errorDetail = response.error ?? `HTTP ${response.status}`;
-        log23.warn("webhook.attempt-failed", { event: payload.event, url: targetLabel, attempt: attempt + 1, maxRetries, httpStatus: response.status, error: errorDetail });
+        log24.warn("webhook.attempt-failed", { event: payload.event, url: targetLabel, attempt: attempt + 1, maxRetries, httpStatus: response.status, error: errorDetail });
         lastStatusClass = response.status === 0 && response.timedOut ? "timeout" : statusClassOf(response.status);
         lastFailure = { reasonCode: webhookResponseReason(response) ?? "UNKNOWN" };
         if (attempt === maxRetries - 1) {
@@ -15665,7 +16168,7 @@ var Notifier = class {
         lastFailure = outcomeFailure(err);
         if (attempt === maxRetries - 1) {
           this.logDelivery(projectId, notificationId, payload.event, "failed", errorDetail);
-          log23.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
+          log24.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
         }
       }
       if (attempt < maxRetries - 1) {
@@ -15684,7 +16187,7 @@ var Notifier = class {
   }
   logDelivery(projectId, notificationId, event, status, error) {
     this.db.insert(auditLog).values({
-      id: crypto21.randomUUID(),
+      id: crypto22.randomUUID(),
       projectId,
       actor: "scheduler",
       action: `notification.${status}`,
@@ -15697,8 +16200,8 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-import { eq as eq25 } from "drizzle-orm";
-var log24 = createLogger("RunCoordinator");
+import { eq as eq26 } from "drizzle-orm";
+var log25 = createLogger("RunCoordinator");
 function reportInsightsGenerated(runTrigger, outcome) {
   trackFeatureCompleted({
     feature: "insights",
@@ -15731,22 +16234,22 @@ var RunCoordinator = class {
    */
   onAnswersRecorded;
   async onRunCompleted(runId, projectId, opts) {
-    const runRow = this.db.select().from(runs).where(eq25(runs.id, runId)).get();
+    const runRow = this.db.select().from(runs).where(eq26(runs.id, runId)).get();
     const kind = runRow?.kind ?? RunKinds["answer-visibility"];
     if (runRow?.trigger === RunTriggers.probe) {
-      log24.info("probe.skip-side-effects", { runId, projectId, kind });
+      log25.info("probe.skip-side-effects", { runId, projectId, kind });
       return;
     }
     if (kind === RunKinds["answer-visibility"] && (runRow?.status === RunStatuses.completed || runRow?.status === RunStatuses.partial) && this.onAnswersRecorded) {
       try {
         await this.onAnswersRecorded(runId, projectId);
       } catch (err) {
-        log24.error("answers-recorded.failed", { runId, projectId, error: describeError(err) });
+        log25.error("answers-recorded.failed", { runId, projectId, error: describeError(err) });
       }
     }
     const completeness = measurementRunCompleteness(this.db, runId);
     if (completeness.planned && !completeness.complete) {
-      log24.info("measurement.incomplete-skip-derived", {
+      log25.info("measurement.incomplete-skip-derived", {
         runId,
         projectId,
         executed: completeness.executed,
@@ -15755,7 +16258,7 @@ var RunCoordinator = class {
       try {
         await this.notifier.onRunCompleted(runId, projectId);
       } catch (err) {
-        log24.error("notifier.failed", { runId, error: describeError(err) });
+        log25.error("notifier.failed", { runId, error: describeError(err) });
       }
       return;
     }
@@ -15763,7 +16266,7 @@ var RunCoordinator = class {
       try {
         await this.onSentimentCompleted(runId, projectId);
       } catch {
-        log24.error("sentiment.wakeup-failed", { runId, projectId });
+        log25.error("sentiment.wakeup-failed", { runId, projectId });
       }
     }
     let insightCount = 0;
@@ -15783,12 +16286,12 @@ var RunCoordinator = class {
             try {
               await this.onInsightsGenerated(runId, projectId, result);
             } catch (err) {
-              log24.error("insight-webhook.failed", { runId, error: describeError(err) });
+              log25.error("insight-webhook.failed", { runId, error: describeError(err) });
             }
           }
         }
       } catch (err) {
-        log24.error("intelligence.failed", { runId, error: describeError(err) });
+        log25.error("intelligence.failed", { runId, error: describeError(err) });
         insightsOutcome = { status: OutcomeStatuses.failed, ...outcomeFailure(err), durationBucket: elapsed() };
       }
       reportInsightsGenerated(runRow?.trigger, insightsOutcome);
@@ -15806,24 +16309,24 @@ var RunCoordinator = class {
           try {
             await this.onInsightsGenerated(runId, projectId, analysisResultFromInsights(gbpInsights));
           } catch (err) {
-            log24.error("gbp-insight-webhook.failed", { runId, error: describeError(err) });
+            log25.error("gbp-insight-webhook.failed", { runId, error: describeError(err) });
           }
         }
       } catch (err) {
-        log24.error("gbp-intelligence.failed", { runId, error: describeError(err) });
+        log25.error("gbp-intelligence.failed", { runId, error: describeError(err) });
         insightsOutcome = { status: OutcomeStatuses.failed, ...outcomeFailure(err), durationBucket: elapsed() };
       }
       reportInsightsGenerated(runRow?.trigger, insightsOutcome);
       try {
         await this.notifier.dispatchReviewAlerts(projectId);
       } catch (err) {
-        log24.error("review-webhook.failed", { runId, error: describeError(err) });
+        log25.error("review-webhook.failed", { runId, error: describeError(err) });
       }
     }
     try {
       await (opts ? this.notifier.onRunCompleted(runId, projectId, opts) : this.notifier.onRunCompleted(runId, projectId));
     } catch (err) {
-      log24.error("notifier.failed", { runId, error: describeError(err) });
+      log25.error("notifier.failed", { runId, error: describeError(err) });
     }
     if (this.onAeroEvent) {
       try {
@@ -15836,7 +16339,7 @@ var RunCoordinator = class {
         };
         await this.onAeroEvent(ctx);
       } catch (err) {
-        log24.error("aero.failed", { runId, error: describeError(err) });
+        log25.error("aero.failed", { runId, error: describeError(err) });
       }
     }
   }
@@ -15851,7 +16354,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(eq25(discoverySessions.runId, runId)).get();
+    const session = this.db.select().from(discoverySessions).where(eq26(discoverySessions.runId, runId)).get();
     const competitorMap = session ? session.competitorMap : [];
     return {
       kind: RunKinds["aeo-discover-probe"],
@@ -15893,13 +16396,13 @@ function analysisResultFromInsights(insights2) {
 }
 
 // src/agent/session-registry.ts
-import crypto23 from "crypto";
-import { eq as eq28 } from "drizzle-orm";
+import crypto24 from "crypto";
+import { eq as eq29 } from "drizzle-orm";
 
 // src/agent/remote-mcp.ts
 import { Type } from "@earendil-works/pi-ai";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
-var log25 = createLogger("RemoteMcp");
+var log26 = createLogger("RemoteMcp");
 var AERO_EXCLUDED_MCP_TOOLS = /* @__PURE__ */ new Set([]);
 async function connectStreamableHttp(server) {
   const transport = new StreamableHTTPClientTransport(new URL(server.url), {
@@ -15967,7 +16470,7 @@ async function loadExternalMcpTools(servers, opts = {}) {
     try {
       client = await connect(server);
     } catch (err) {
-      log25.error("external-mcp.connect-failed", {
+      log26.error("external-mcp.connect-failed", {
         label,
         error: describeError(err)
       });
@@ -15977,7 +16480,7 @@ async function loadExternalMcpTools(servers, opts = {}) {
     try {
       listed = await client.listTools();
     } catch (err) {
-      log25.error("external-mcp.list-failed", {
+      log26.error("external-mcp.list-failed", {
         label,
         error: describeError(err)
       });
@@ -15988,7 +16491,7 @@ async function loadExternalMcpTools(servers, opts = {}) {
       if (!isReadOnly(tool)) continue;
       tools.push(adaptRemoteTool(client, tool));
     }
-    log25.info("external-mcp.loaded", {
+    log26.info("external-mcp.loaded", {
       label,
       discovered: listed.tools.length,
       adopted: tools.length
@@ -15998,8 +16501,8 @@ async function loadExternalMcpTools(servers, opts = {}) {
 }
 
 // src/agent/memory-store.ts
-import crypto22 from "crypto";
-import { and as and22, desc as desc10, eq as eq26, like, sql as sql11, or as or3 } from "drizzle-orm";
+import crypto23 from "crypto";
+import { and as and23, desc as desc10, eq as eq27, like, sql as sql12, or as or3 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -16013,7 +16516,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq26(agentMemory.projectId, projectId)).orderBy(desc10(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq27(agentMemory.projectId, projectId)).orderBy(desc10(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -16027,7 +16530,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 = crypto22.randomUUID();
+  const id = crypto23.randomUUID();
   db.insert(agentMemory).values({
     id,
     projectId: args.projectId,
@@ -16044,21 +16547,21 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and22(eq26(agentMemory.projectId, args.projectId), eq26(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and23(eq27(agentMemory.projectId, args.projectId), eq27(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(and22(eq26(agentMemory.projectId, projectId), eq26(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and23(eq27(agentMemory.projectId, projectId), eq27(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
 function loadRecentForHydrate(db, projectId, limit, sessionId) {
   if (sessionId === void 0) return listMemoryEntries(db, projectId, { limit });
   const sessionPrefix = `compaction:${sessionId ?? ""}:`;
-  return db.select().from(agentMemory).where(and22(
-    eq26(agentMemory.projectId, projectId),
-    or3(sql11`substr(${agentMemory.key}, 1, ${COMPACTION_KEY_PREFIX.length}) <> ${COMPACTION_KEY_PREFIX}`, sessionId ? sql11`substr(${agentMemory.key}, 1, ${sessionPrefix.length}) = ${sessionPrefix}` : void 0)
+  return db.select().from(agentMemory).where(and23(
+    eq27(agentMemory.projectId, projectId),
+    or3(sql12`substr(${agentMemory.key}, 1, ${COMPACTION_KEY_PREFIX.length}) <> ${COMPACTION_KEY_PREFIX}`, sessionId ? sql12`substr(${agentMemory.key}, 1, ${sessionPrefix.length}) = ${sessionPrefix}` : void 0)
   )).orderBy(desc10(agentMemory.updatedAt)).limit(limit).all().map(rowToDto);
 }
 function writeCompactionNote(db, args) {
@@ -16069,7 +16572,7 @@ function writeCompactionNote(db, args) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const key = `${COMPACTION_KEY_PREFIX}${args.sessionId}:${now}`;
-  const id = crypto22.randomUUID();
+  const id = crypto23.randomUUID();
   let inserted;
   db.transaction((tx) => {
     tx.insert(agentMemory).values({
@@ -16083,16 +16586,16 @@ 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(
-      and22(
-        eq26(agentMemory.projectId, args.projectId),
+      and23(
+        eq27(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
     ).orderBy(desc10(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
-      tx.delete(agentMemory).where(sql11`${agentMemory.id} IN (${sql11.join(stale.map((s) => sql11`${s}`), sql11`, `)})`).run();
+      tx.delete(agentMemory).where(sql12`${agentMemory.id} IN (${sql12.join(stale.map((s) => sql12`${s}`), sql12`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and22(eq26(agentMemory.projectId, args.projectId), eq26(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and23(eq27(agentMemory.projectId, args.projectId), eq27(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -16166,7 +16669,7 @@ function trackAeroTurn(agent, turn) {
 }
 
 // src/agent/project-shape.ts
-import { and as and23, count as count4, eq as eq27 } from "drizzle-orm";
+import { and as and24, count as count5, eq as eq28 } from "drizzle-orm";
 var ADVANCED_TOOLS = [
   "canonry_measurement_portfolio_summary",
   "canonry_measurement_overview",
@@ -16193,10 +16696,10 @@ var ADVANCED_ROUTES = [
 ];
 function aeroProjectShape(db, projectId) {
   try {
-    const pointer = db.select().from(measurementPlans).where(eq27(measurementPlans.projectId, projectId)).get();
-    const version = pointer ? db.select().from(measurementPlanVersions).where(and23(
-      eq27(measurementPlanVersions.projectId, projectId),
-      eq27(measurementPlanVersions.id, pointer.activeVersionId)
+    const pointer = db.select().from(measurementPlans).where(eq28(measurementPlans.projectId, projectId)).get();
+    const version = pointer ? db.select().from(measurementPlanVersions).where(and24(
+      eq28(measurementPlanVersions.projectId, projectId),
+      eq28(measurementPlanVersions.id, pointer.activeVersionId)
     )).get() : void 0;
     if (version) {
       const plan = JSON.parse(version.canonicalJson);
@@ -16223,7 +16726,7 @@ canonry_visibility_report describes the whole project, not one Property. canonry
         pinned: ADVANCED_TOOLS
       };
     }
-    const tracked = db.select({ total: count4() }).from(queries).where(eq27(queries.projectId, projectId)).get()?.total ?? 0;
+    const tracked = db.select({ total: count5() }).from(queries).where(eq28(queries.projectId, projectId)).get()?.total ?? 0;
     return {
       prompt: `
 
@@ -16363,7 +16866,7 @@ async function compactMessages(args) {
 }
 
 // src/agent/session-registry.ts
-var log26 = createLogger("SessionRegistry");
+var log27 = createLogger("SessionRegistry");
 var MAX_HYDRATE_NOTES = 20;
 var MAX_HYDRATE_BYTES = 32 * 1024;
 function escapeMemoryFragment(value) {
@@ -16422,7 +16925,7 @@ var SessionRegistry = class {
     if (!this.externalToolsPromise) {
       this.externalToolsPromise = loadExternalMcpTools(this.opts.config.externalMcpServers).catch(
         (err) => {
-          log26.error("external-mcp.load-failed", {
+          log27.error("external-mcp.load-failed", {
             error: describeError(err)
           });
           return [];
@@ -16479,7 +16982,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq28(agentSessions.projectId, projectId)).run();
+        }).where(eq29(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -16508,7 +17011,7 @@ var SessionRegistry = class {
       return agent2;
     }
     const { provider, modelId } = resolveSessionProviderAndModel(this.opts.config, preferences);
-    const sessionId = crypto23.randomUUID();
+    const sessionId = crypto24.randomUUID();
     const agent = createAeroSession({
       projectName,
       client: this.opts.client,
@@ -16698,13 +17201,13 @@ ${lines.join("\n")}
       agent.state.messages = result.messages;
       setAeroSystemPrompt(agent, this.buildHydratedSystemPrompt(projectId, row.systemPrompt));
       this.save(projectName);
-      log26.info("compaction.completed", {
+      log27.info("compaction.completed", {
         projectName,
         removedCount: result.removedCount,
         summaryBytes: Buffer.byteLength(result.summary, "utf8")
       });
     } catch (err) {
-      log26.error("compaction.failed", {
+      log27.error("compaction.failed", {
         projectName,
         error: describeError(err)
       });
@@ -16798,7 +17301,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq28(agentSessions.projectId, projectId)).run();
+    }).where(eq29(agentSessions.projectId, projectId)).run();
   }
   /** Snapshot pending work without consuming it before an atomic conversation switch. */
   prepareConversationChange(projectName) {
@@ -16882,7 +17385,7 @@ ${lines.join("\n")}
       }
       trackAeroTurn(agent, { trigger: OutcomeTriggers.agent });
     } catch (err) {
-      log26.error("drain.failed", {
+      log27.error("drain.failed", {
         projectName,
         error: describeError(err)
       });
@@ -16979,18 +17482,18 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq28(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq29(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq28(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq29(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const modelProvider = params.provider ?? params.modelProvider ?? AgentProviderIds.claude;
     this.opts.db.insert(agentSessions).values({
-      id: params.id ?? crypto23.randomUUID(),
+      id: params.id ?? crypto24.randomUUID(),
       projectId: params.projectId,
       systemPrompt: params.systemPrompt,
       modelProvider,
@@ -17003,7 +17506,7 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq28(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq29(agentSessions.projectId, projectId)).run();
   }
   /**
    * Store a refreshed prompt snapshot without touching `updatedAt`, which the
@@ -17012,13 +17515,13 @@ ${lines.join("\n")}
    * recently used right after an upgrade.
    */
   persistPromptSnapshot(projectId, systemPrompt) {
-    this.opts.db.update(agentSessions).set({ systemPrompt }).where(eq28(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ systemPrompt }).where(eq29(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/viewer-sessions.ts
-import crypto24 from "crypto";
-import { and as and24, eq as eq29, isNotNull as isNotNull4, like as like2 } from "drizzle-orm";
+import crypto25 from "crypto";
+import { and as and25, eq as eq30, isNotNull as isNotNull4, like as like2 } from "drizzle-orm";
 var AERO_VIEWER_EXCLUDED_MCP_TOOLS = /* @__PURE__ */ new Set([
   CanonryMcpToolNames.canonry_ads_account,
   CanonryMcpToolNames.canonry_ads_geo_search,
@@ -17071,8 +17574,8 @@ function trimViewerTranscript(messages, max2 = MAX_VIEWER_MESSAGES) {
 }
 var VIEWER_IDLE_MS = 12 * 60 * 60 * 1e3;
 function mintViewerAeroKey(db, userId, now = /* @__PURE__ */ new Date()) {
-  const raw = `cnry_${crypto24.randomBytes(24).toString("hex")}`;
-  const id = crypto24.randomUUID();
+  const raw = `cnry_${crypto25.randomBytes(24).toString("hex")}`;
+  const id = crypto25.randomUUID();
   db.insert(apiKeys).values({
     id,
     name: `${VIEWER_AERO_KEY_PREFIX}${userId}`,
@@ -17131,8 +17634,8 @@ var ViewerAeroSessions = class {
     if (this.isBusy(project.name, userId)) throw agentBusy(project.name);
     const today = new Date(this.now()).toISOString().slice(0, 10);
     const used = this.turnsToday.get(key);
-    const count5 = used?.date === today ? used.count : 0;
-    if (count5 >= VIEWER_AERO_DAILY_TURN_LIMIT) throw viewerAeroDailyLimitExceeded(VIEWER_AERO_DAILY_TURN_LIMIT);
+    const count6 = used?.date === today ? used.count : 0;
+    if (count6 >= VIEWER_AERO_DAILY_TURN_LIMIT) throw viewerAeroDailyLimitExceeded(VIEWER_AERO_DAILY_TURN_LIMIT);
     const minted = mintViewerAeroKey(this.opts.db, userId, new Date(this.now()));
     this.acquisitions.add(key);
     let handedOff = false;
@@ -17147,7 +17650,7 @@ var ViewerAeroSessions = class {
       setAeroSystemPrompt(agent, loadAeroSystemPrompt(void 0, { extras: false }) + VIEWER_AERO_PROMPT + shape.prompt + aeroViewPrompt(preferences.context));
       configureAeroRuntime(agent, [...buildViewerAeroTools(client, project.name, this.opts.managedSweeps), buildAeroViewTool(view, evidence)], void 0, true, shape.pinned);
       this.sessions.set(key, { agent, lastUsedAt: this.now(), updatedAt: this.sessions.get(key)?.updatedAt ?? null });
-      this.turnsToday.set(key, { date: today, count: count5 + 1 });
+      this.turnsToday.set(key, { date: today, count: count6 + 1 });
       handedOff = true;
       let released = false;
       return {
@@ -17195,12 +17698,12 @@ var ViewerAeroSessions = class {
    */
   removeKey(id) {
     try {
-      this.opts.db.delete(apiKeys).where(eq29(apiKeys.id, id)).run();
+      this.opts.db.delete(apiKeys).where(eq30(apiKeys.id, id)).run();
     } catch {
       try {
         this.opts.db.transaction((tx) => {
-          tx.delete(dashboardSessions).where(eq29(dashboardSessions.apiKeyId, id)).run();
-          tx.update(apiKeys).set({ revokedAt: new Date(this.now()).toISOString() }).where(eq29(apiKeys.id, id)).run();
+          tx.delete(dashboardSessions).where(eq30(dashboardSessions.apiKeyId, id)).run();
+          tx.update(apiKeys).set({ revokedAt: new Date(this.now()).toISOString() }).where(eq30(apiKeys.id, id)).run();
         });
       } catch {
       }
@@ -17213,7 +17716,7 @@ var ViewerAeroSessions = class {
    */
   revokeOrphanedKeys() {
     try {
-      this.opts.db.delete(apiKeys).where(and24(like2(apiKeys.name, `${VIEWER_AERO_KEY_PREFIX}%`), isNotNull4(apiKeys.delegatedUserId))).run();
+      this.opts.db.delete(apiKeys).where(and25(like2(apiKeys.name, `${VIEWER_AERO_KEY_PREFIX}%`), isNotNull4(apiKeys.delegatedUserId))).run();
     } catch {
     }
   }
@@ -17228,9 +17731,9 @@ var ViewerAeroSessions = class {
 };
 
 // src/mcp-http.ts
-import crypto25 from "crypto";
+import crypto26 from "crypto";
 import { isIP } from "net";
-import { and as and25, eq as eq30, isNull as isNull6 } from "drizzle-orm";
+import { and as and26, eq as eq31, isNull as isNull6 } from "drizzle-orm";
 import { NodeStreamableHTTPServerTransport, toNodeHandler, toWebRequest } from "@modelcontextprotocol/node";
 import { McpServer, createMcpHandler, isInitializeRequest, isLegacyRequest } from "@modelcontextprotocol/server";
 var SESSION_IDLE_MS = 10 * 60 * 1e3;
@@ -17239,8 +17742,8 @@ var MAX_CLEANUP_RETRIES_PER_SWEEP = 8;
 var MAX_PENDING_KEY_RETIREMENTS = 256;
 var MAX_CLEANUP_BACKOFF_MS = 10 * 60 * 1e3;
 function mintSessionKey(db, scopes, userId, oauthGrantId, createdAt) {
-  const raw = `cnry_${crypto25.randomBytes(24).toString("hex")}`;
-  const id = crypto25.randomUUID();
+  const raw = `cnry_${crypto26.randomBytes(24).toString("hex")}`;
+  const id = crypto26.randomUUID();
   db.insert(apiKeys).values({
     id,
     name: `mcp-session:${userId}`,
@@ -17336,12 +17839,12 @@ function registerMcpHttpRoutes(scope, opts) {
     try {
       withoutLockWait(() => {
         opts.db.transaction((tx) => {
-          tx.delete(dashboardSessions).where(eq30(dashboardSessions.apiKeyId, id)).run();
-          tx.update(apiKeys).set({ revokedAt: new Date(now()).toISOString() }).where(and25(eq30(apiKeys.id, id), isNull6(apiKeys.revokedAt))).run();
+          tx.delete(dashboardSessions).where(eq31(dashboardSessions.apiKeyId, id)).run();
+          tx.update(apiKeys).set({ revokedAt: new Date(now()).toISOString() }).where(and26(eq31(apiKeys.id, id), isNull6(apiKeys.revokedAt))).run();
         });
         if (remove) {
           try {
-            opts.db.delete(apiKeys).where(eq30(apiKeys.id, id)).run();
+            opts.db.delete(apiKeys).where(eq31(apiKeys.id, id)).run();
           } catch (error) {
             scope.log.warn({ err: error, keyId: id }, "Retained revoked MCP request key after deletion failed");
           }
@@ -17392,14 +17895,14 @@ function registerMcpHttpRoutes(scope, opts) {
       withoutLockWait(() => {
         const cutoff = now() - SESSION_IDLE_MS;
         for (const session of legacyServers) {
-          const key = session.sessionKeyId ? opts.db.select({ revokedAt: apiKeys.revokedAt }).from(apiKeys).where(eq30(apiKeys.id, session.sessionKeyId)).get() : void 0;
+          const key = session.sessionKeyId ? opts.db.select({ revokedAt: apiKeys.revokedAt }).from(apiKeys).where(eq31(apiKeys.id, session.sessionKeyId)).get() : void 0;
           if (session.lastSeenAt < cutoff || session.expiresAt !== void 0 && session.expiresAt <= now() || session.sessionKeyId && (!key || key.revokedAt)) {
             void session.close().catch((error) => scope.log.error({ err: error }, "Failed to close expired MCP session"));
           }
         }
         for (const exchange of modernExchanges) {
           if (!exchange.sessionKey) continue;
-          const key = opts.db.select({ revokedAt: apiKeys.revokedAt }).from(apiKeys).where(eq30(apiKeys.id, exchange.sessionKey.id)).get();
+          const key = opts.db.select({ revokedAt: apiKeys.revokedAt }).from(apiKeys).where(eq31(apiKeys.id, exchange.sessionKey.id)).get();
           if (!key || key.revokedAt || exchange.sessionKey.expiresAt <= now()) {
             void exchange.close().catch((error) => scope.log.error({ err: error }, "Failed to close expired MCP request"));
           }
@@ -17454,7 +17957,7 @@ function registerMcpHttpRoutes(scope, opts) {
       clientName: `canonry-mcp/${PACKAGE_VERSION}`,
       surface: "mcp-http",
       // Correlation only: this is never accepted as caller identity or authority.
-      ...modern ? {} : { actorSession: crypto25.randomUUID() }
+      ...modern ? {} : { actorSession: crypto26.randomUUID() }
     });
     let server;
     try {
@@ -17479,7 +17982,7 @@ function registerMcpHttpRoutes(scope, opts) {
     if (!bearer) return null;
     const { server, sessionKey } = createAuthorizedServer(request, segment, bearer);
     const transport = new NodeStreamableHTTPServerTransport({
-      sessionIdGenerator: () => crypto25.randomUUID(),
+      sessionIdGenerator: () => crypto26.randomUUID(),
       onsessioninitialized: (id) => {
         if (!shuttingDown && !closing) sessions.set(id, session);
       }
@@ -17649,7 +18152,7 @@ function registerMcpHttpRoutes(scope, opts) {
 }
 
 // src/agent/agent-routes.ts
-import { eq as eq31 } from "drizzle-orm";
+import { eq as eq32 } from "drizzle-orm";
 function viewerAeroCaller(request, opts) {
   if (!opts.viewerSessions) return null;
   const principal = request.principal;
@@ -17689,7 +18192,7 @@ function turnAttribution(request) {
   };
 }
 function resolveProject(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq31(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq32(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -17808,7 +18311,7 @@ function registerAgentRoutes(app, opts) {
       }
       requireInstanceAdministrator(request);
       const project = resolveProject(opts.db, request.params.name);
-      const row = opts.db.select().from(agentSessions).where(eq31(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq32(agentSessions.projectId, project.id)).get();
       const nextTurn = opts.sessionRegistry.nextTurnModel(project.name);
       if (!row) {
         return { conversationId: null, messages: [], modelProvider: null, modelId: null, nextTurn, updatedAt: null };
@@ -17850,7 +18353,7 @@ function registerAgentRoutes(app, opts) {
       const project = resolveProject(opts.db, request.params.name);
       if (opts.sessionRegistry.isBusy(project.name)) throw agentBusy(project.name);
       opts.sessionRegistry.reset(project.name);
-      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq31(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq32(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -17874,7 +18377,7 @@ function registerAgentRoutes(app, opts) {
       return streamViewerTurn(opts, project, viewerId, body, reply, turnAttribution(request));
     }
     if (body.conversationId !== void 0) {
-      const current = opts.db.select({ id: agentSessions.id }).from(agentSessions).where(eq31(agentSessions.projectId, project.id)).get();
+      const current = opts.db.select({ id: agentSessions.id }).from(agentSessions).where(eq32(agentSessions.projectId, project.id)).get();
       if ((current?.id ?? null) !== body.conversationId) throw validationError("The active conversation changed. Reload the conversation before sending.");
     }
     const promptText = body.prompt;
@@ -18285,7 +18788,7 @@ function stripHtml(html) {
 }
 
 // src/snapshot-service.ts
-var log27 = createLogger("Snapshot");
+var log28 = createLogger("Snapshot");
 var ANALYSIS_PROVIDER_PRIORITY = ["openai", "claude", "gemini", "perplexity", "muse", "local"];
 var SNAPSHOT_QUERY_COUNT = 6;
 var SnapshotService = class {
@@ -18387,7 +18890,7 @@ var SnapshotService = class {
       return mapAuditReport(report);
     } catch (err) {
       const message = describeError(err);
-      log27.warn("audit.failed", { homepageUrl, error: message });
+      log28.warn("audit.failed", { homepageUrl, error: message });
       return {
         url: homepageUrl,
         finalUrl: homepageUrl,
@@ -18416,7 +18919,7 @@ var SnapshotService = class {
           queries: parsedQueries
         };
       } catch (err) {
-        log27.warn("profile.generation-failed", {
+        log28.warn("profile.generation-failed", {
           domain: ctx.domain,
           provider: ctx.analysisProvider.adapter.name,
           error: describeError(err)
@@ -18564,7 +19067,7 @@ var SnapshotService = class {
         recommendedActions: uniqueStrings2(parsed.recommendedActions ?? []).slice(0, 4)
       };
     } catch (err) {
-      log27.warn("response.analysis-failed", {
+      log28.warn("response.analysis-failed", {
         provider: ctx.analysisProvider.adapter.name,
         error: describeError(err)
       });
@@ -18690,7 +19193,7 @@ function buildSnapshotSummary(companyName, queries2, providers, queryResults, au
       competitorCounts.set(competitor, (competitorCounts.get(competitor) ?? 0) + 1);
     }
   }
-  const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count5]) => ({ name, count: count5 }));
+  const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count6]) => ({ name, count: count6 }));
   const defaultMeaning = totalComparisons > 0 ? `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider-query response${totalComparisons === 1 ? "" : "s"} across ${queries2.length} category queries.` : `No successful provider responses were returned across ${queries2.length} category queries.`;
   const failureNote = failedComparisons > 0 ? [
     `${failedComparisons} provider response${failedComparisons === 1 ? "" : "s"} failed and ${failedComparisons === 1 ? "was" : "were"} excluded from visibility totals.`
@@ -18834,7 +19337,7 @@ function clipText(value, length) {
 }
 
 // src/research-runner.ts
-import { and as and26, eq as eq32, inArray as inArray13, sql as sql12 } from "drizzle-orm";
+import { and as and27, eq as eq33, inArray as inArray13, sql as sql13 } from "drizzle-orm";
 var unfinishedResearchQueryStatuses = [ResearchQueryStatuses.queued, ResearchQueryStatuses.running];
 function finalResearchRunStatus(completed, failed, waiting) {
   if (waiting > 0) return ResearchRunStatuses["waiting-upstream"];
@@ -18842,13 +19345,13 @@ function finalResearchRunStatus(completed, failed, waiting) {
   return completed > 0 ? ResearchRunStatuses.partial : ResearchRunStatuses.failed;
 }
 async function executeResearchRun(db, registry, runId, projectId, options = {}) {
-  const run = db.select().from(researchRuns).where(and26(eq32(researchRuns.id, runId), eq32(researchRuns.projectId, projectId))).get();
+  const run = db.select().from(researchRuns).where(and27(eq33(researchRuns.id, runId), eq33(researchRuns.projectId, projectId))).get();
   if (!run || run.status !== ResearchRunStatuses.queued) return;
-  const project = db.select().from(projects).where(eq32(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq33(projects.id, projectId)).get();
   if (!project) return;
   const provider = registry.get(run.provider);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and26(eq32(researchRuns.id, runId), eq32(researchRuns.status, ResearchRunStatuses.queued))).run();
+  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and27(eq33(researchRuns.id, runId), eq33(researchRuns.status, ResearchRunStatuses.queued))).run();
   if (claim.changes !== 1) return;
   const elapsed = startOutcomeTimer();
   const requested = currentOutcomeOrigin();
@@ -18882,8 +19385,8 @@ async function executeResearchRun(db, registry, runId, projectId, options = {})
     }
     reserved = run.totalQueries;
     reservation = { scope, period };
-    const rows = db.select().from(researchRunQueries).where(eq32(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
-    const competitorRows = db.select(competitorIdentityColumns).from(competitors).where(eq32(competitors.projectId, projectId)).orderBy(competitors.domain).all();
+    const rows = db.select().from(researchRunQueries).where(eq33(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
+    const competitorRows = db.select(competitorIdentityColumns).from(competitors).where(eq33(competitors.projectId, projectId)).orderBy(competitors.domain).all();
     const competitorDomains = competitorRows.map((row) => row.domain);
     const competitorAliases = new Map(competitorRows.map((row) => [row.domain, competitorIdentityAliases(row)]).filter(([, aliases]) => aliases.length > 0));
     const domains = effectiveDomains(project);
@@ -18893,7 +19396,7 @@ async function executeResearchRun(db, registry, runId, projectId, options = {})
     await mapWithConcurrency(rows, Math.max(1, provider.config.quotaPolicy.maxConcurrency), async (row) => {
       try {
         const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and26(eq32(researchRunQueries.id, row.id), eq32(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
+        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and27(eq33(researchRunQueries.id, row.id), eq33(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
         const raw = await gate.run(async () => {
           dispatched++;
           return provider.adapter.executeTrackedQuery({ query: row.queryText, canonicalDomains: domains, competitorDomains, ...run.location ? { location: run.location } : {} }, config);
@@ -18924,7 +19427,7 @@ async function executeResearchRun(db, registry, runId, projectId, options = {})
           rawResponse: raw.rawResponse,
           answerEvidence: raw.evidence ?? null,
           finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(and26(eq32(researchRunQueries.id, row.id), eq32(researchRunQueries.status, ResearchQueryStatuses.running))).run();
+        }).where(and27(eq33(researchRunQueries.id, row.id), eq33(researchRunQueries.status, ResearchQueryStatuses.running))).run();
         if (completed.changes === 1) incrementResearchProgress(db, runId, "completedQueries");
       } catch (error) {
         if (!(error instanceof IncompleteAnswerError && error.resumable)) queryFailure ??= error;
@@ -18975,11 +19478,11 @@ function researchOutcomeStatus(status) {
   }
 }
 function incrementResearchProgress(db, runId, column) {
-  db.update(researchRuns).set({ [column]: sql12`${researchRuns[column]} + 1` }).where(eq32(researchRuns.id, runId)).run();
+  db.update(researchRuns).set({ [column]: sql13`${researchRuns[column]} + 1` }).where(eq33(researchRuns.id, runId)).run();
 }
 function markResearchQueryFailed(db, runId, queryId, error) {
   const message = describeError(error);
-  const unfinished = and26(eq32(researchRunQueries.id, queryId), inArray13(researchRunQueries.status, unfinishedResearchQueryStatuses));
+  const unfinished = and27(eq33(researchRunQueries.id, queryId), inArray13(researchRunQueries.status, unfinishedResearchQueryStatuses));
   if (error instanceof IncompleteAnswerError && error.resumable) {
     db.update(researchRunQueries).set({
       status: ResearchQueryStatuses["waiting-upstream"],
@@ -18995,10 +19498,10 @@ function markResearchQueryFailed(db, runId, queryId, error) {
   if (failed.changes === 1) incrementResearchProgress(db, runId, "failedQueries");
 }
 function markUnfinishedResearchQueriesFailed(db, runId, error) {
-  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and26(eq32(researchRunQueries.researchRunId, runId), inArray13(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and27(eq33(researchRunQueries.researchRunId, runId), inArray13(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
 }
 function finalizeResearchRun(db, runId, fatalError) {
-  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq32(researchRunQueries.researchRunId, runId)).all();
+  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq33(researchRunQueries.researchRunId, runId)).all();
   const completed = rows.filter((row) => row.status === ResearchQueryStatuses.completed).length;
   const failed = rows.filter((row) => row.status === ResearchQueryStatuses.failed).length;
   const waiting = rows.filter((row) => row.status === ResearchQueryStatuses["waiting-upstream"]).length;
@@ -19010,12 +19513,12 @@ function finalizeResearchRun(db, runId, fatalError) {
     error: fatalError ?? (failed === rows.length ? "Every research query failed." : null),
     // A run waiting on upstream jobs has not finished.
     finishedAt: waiting > 0 ? null : (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq32(researchRuns.id, runId)).run();
+  }).where(eq33(researchRuns.id, runId)).run();
   return { status, total: rows.length, completed, failed };
 }
 
 // src/google-marketing-sync.ts
-import { and as and27, eq as eq33, isNull as isNull7, sql as sql13 } from "drizzle-orm";
+import { and as and28, eq as eq34, isNull as isNull7, sql as sql14 } from "drizzle-orm";
 var RUNTIME_FAILURE_REASONS = {
   INVALID_INPUT: OutcomeReasonCodes.VALIDATION,
   NOT_CONFIGURED: OutcomeReasonCodes.NOT_CONNECTED,
@@ -19052,10 +19555,10 @@ function assertSnapshotContext(metadata, expected) {
   }
 }
 function requireSyncRun(db, runId, projectId, kind) {
-  const run = db.select().from(runs).where(and27(
-    eq33(runs.id, runId),
-    eq33(runs.projectId, projectId),
-    eq33(runs.kind, kind)
+  const run = db.select().from(runs).where(and28(
+    eq34(runs.id, runId),
+    eq34(runs.projectId, projectId),
+    eq34(runs.kind, kind)
   )).get();
   if (!run) throw withOutcomeReason(new Error(`Run ${runId} is not a ${kind} run for this project.`), OutcomeReasonCodes.NOT_FOUND);
   if (run.status !== RunStatuses.queued) {
@@ -19071,19 +19574,19 @@ function markFailed(db, runId, projectId, kind, expectedStatus, error) {
     status: RunStatuses.failed,
     error: serializeRunError({ message: safeErrorMessage(error) }),
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(and27(
-    eq33(runs.id, runId),
-    eq33(runs.projectId, projectId),
-    eq33(runs.kind, kind),
-    eq33(runs.status, expectedStatus)
+  }).where(and28(
+    eq34(runs.id, runId),
+    eq34(runs.projectId, projectId),
+    eq34(runs.kind, kind),
+    eq34(runs.status, expectedStatus)
   )).run();
 }
 function claimSyncRun(db, runId, projectId, kind, startedAt) {
-  const claim = db.update(runs).set({ status: RunStatuses.running, startedAt, error: null }).where(and27(
-    eq33(runs.id, runId),
-    eq33(runs.projectId, projectId),
-    eq33(runs.kind, kind),
-    eq33(runs.status, RunStatuses.queued)
+  const claim = db.update(runs).set({ status: RunStatuses.running, startedAt, error: null }).where(and28(
+    eq34(runs.id, runId),
+    eq34(runs.projectId, projectId),
+    eq34(runs.kind, kind),
+    eq34(runs.status, RunStatuses.queued)
   )).run();
   return claim.changes === 1;
 }
@@ -19093,9 +19596,9 @@ async function executeGoogleAdsMarketingSync(db, runtime, runId, projectId) {
   let evidenceCollected = false;
   try {
     requireSyncRun(db, runId, projectId, RunKinds["google-ads-sync"]);
-    const project = db.select().from(projects).where(eq33(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq34(projects.id, projectId)).get();
     if (!project) throw withOutcomeReason(new Error(`Project ${projectId} was not found.`), OutcomeReasonCodes.NOT_FOUND);
-    const connection = db.select().from(googleAdsConnections).where(eq33(googleAdsConnections.projectId, projectId)).get();
+    const connection = db.select().from(googleAdsConnections).where(eq34(googleAdsConnections.projectId, projectId)).get();
     if (!connection?.selectedCustomerId) {
       throw withOutcomeReason(new Error("Google Ads needs a selected customer before it can sync."), OutcomeReasonCodes.ACCOUNT_NOT_FOUND);
     }
@@ -19147,11 +19650,11 @@ async function executeGoogleAdsMarketingSync(db, runtime, runId, projectId) {
         status: RunStatuses.completed,
         finishedAt,
         error: null
-      }).where(and27(
-        eq33(runs.id, runId),
-        eq33(runs.projectId, projectId),
-        eq33(runs.kind, RunKinds["google-ads-sync"]),
-        eq33(runs.status, RunStatuses.running)
+      }).where(and28(
+        eq34(runs.id, runId),
+        eq34(runs.projectId, projectId),
+        eq34(runs.kind, RunKinds["google-ads-sync"]),
+        eq34(runs.status, RunStatuses.running)
       )).run();
       if (terminalClaim.changes !== 1) {
         throw withOutcomeReason(
@@ -19171,12 +19674,12 @@ async function executeGoogleAdsMarketingSync(db, runtime, runId, projectId) {
         lastMetricsSnapshotAt: result.metrics?.metadata.capturedAt ?? connection.lastMetricsSnapshotAt,
         lastMetricsSnapshotId: result.metrics?.metadata.id ?? connection.lastMetricsSnapshotId,
         updatedAt: finishedAt
-      }).where(and27(
-        eq33(googleAdsConnections.id, connection.id),
-        eq33(googleAdsConnections.projectId, projectId),
-        eq33(googleAdsConnections.selectedCustomerId, connection.selectedCustomerId),
-        connection.selectedLoginCustomerId === null ? isNull7(googleAdsConnections.selectedLoginCustomerId) : eq33(googleAdsConnections.selectedLoginCustomerId, connection.selectedLoginCustomerId),
-        eq33(googleAdsConnections.selectionGeneration, connection.selectionGeneration)
+      }).where(and28(
+        eq34(googleAdsConnections.id, connection.id),
+        eq34(googleAdsConnections.projectId, projectId),
+        eq34(googleAdsConnections.selectedCustomerId, connection.selectedCustomerId),
+        connection.selectedLoginCustomerId === null ? isNull7(googleAdsConnections.selectedLoginCustomerId) : eq34(googleAdsConnections.selectedLoginCustomerId, connection.selectedLoginCustomerId),
+        eq34(googleAdsConnections.selectionGeneration, connection.selectionGeneration)
       )).run();
       if (connectionClaim.changes !== 1) {
         throw withOutcomeReason(
@@ -19216,9 +19719,9 @@ async function executeGtmMarketingSync(db, runtime, runId, projectId) {
   let evidenceCollected = false;
   try {
     requireSyncRun(db, runId, projectId, RunKinds["gtm-sync"]);
-    const project = db.select().from(projects).where(eq33(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq34(projects.id, projectId)).get();
     if (!project) throw withOutcomeReason(new Error(`Project ${projectId} was not found.`), OutcomeReasonCodes.NOT_FOUND);
-    const connection = db.select().from(gtmConnections).where(eq33(gtmConnections.projectId, projectId)).get();
+    const connection = db.select().from(gtmConnections).where(eq34(gtmConnections.projectId, projectId)).get();
     if (!connection?.selectedAccountId || !connection.selectedContainerId) {
       throw withOutcomeReason(new Error("GTM needs a selected account and container before it can sync."), OutcomeReasonCodes.ACCOUNT_NOT_FOUND);
     }
@@ -19256,11 +19759,11 @@ async function executeGtmMarketingSync(db, runtime, runId, projectId) {
         status: RunStatuses.completed,
         finishedAt,
         error: null
-      }).where(and27(
-        eq33(runs.id, runId),
-        eq33(runs.projectId, projectId),
-        eq33(runs.kind, RunKinds["gtm-sync"]),
-        eq33(runs.status, RunStatuses.running)
+      }).where(and28(
+        eq34(runs.id, runId),
+        eq34(runs.projectId, projectId),
+        eq34(runs.kind, RunKinds["gtm-sync"]),
+        eq34(runs.status, RunStatuses.running)
       )).run();
       if (terminalClaim.changes !== 1) {
         throw withOutcomeReason(
@@ -19275,19 +19778,19 @@ async function executeGtmMarketingSync(db, runtime, runId, projectId) {
         selectedWorkspaceName: selectedWorkspace?.name ?? null,
         ...workspaceReplaced ? {
           selectedWorkspaceId: workspaceId,
-          selectionGeneration: sql13`${gtmConnections.selectionGeneration} + 1`
+          selectionGeneration: sql14`${gtmConnections.selectionGeneration} + 1`
         } : {},
         lastValidatedAt: snapshot.metadata.capturedAt,
         lastSnapshotAt: snapshot.metadata.capturedAt,
         lastSnapshotId: snapshot.metadata.id,
         updatedAt: finishedAt
-      }).where(and27(
-        eq33(gtmConnections.id, connection.id),
-        eq33(gtmConnections.projectId, projectId),
-        eq33(gtmConnections.selectedAccountId, connection.selectedAccountId),
-        eq33(gtmConnections.selectedContainerId, connection.selectedContainerId),
-        connection.selectedWorkspaceId === null ? isNull7(gtmConnections.selectedWorkspaceId) : eq33(gtmConnections.selectedWorkspaceId, connection.selectedWorkspaceId),
-        eq33(gtmConnections.selectionGeneration, connection.selectionGeneration)
+      }).where(and28(
+        eq34(gtmConnections.id, connection.id),
+        eq34(gtmConnections.projectId, projectId),
+        eq34(gtmConnections.selectedAccountId, connection.selectedAccountId),
+        eq34(gtmConnections.selectedContainerId, connection.selectedContainerId),
+        connection.selectedWorkspaceId === null ? isNull7(gtmConnections.selectedWorkspaceId) : eq34(gtmConnections.selectedWorkspaceId, connection.selectedWorkspaceId),
+        eq34(gtmConnections.selectionGeneration, connection.selectionGeneration)
       )).run();
       if (connectionClaim.changes !== 1) {
         throw withOutcomeReason(
@@ -19325,7 +19828,7 @@ async function executeGtmMarketingSync(db, runtime, runId, projectId) {
 // src/server.ts
 var _require = createRequire(import.meta.url);
 var { version: PKG_VERSION } = _require("../package.json");
-var log28 = createLogger("Server");
+var log29 = createLogger("Server");
 var runtimeStartupByServer = /* @__PURE__ */ new WeakMap();
 function waitForServerRuntimeStartup(app) {
   const startup = runtimeStartupByServer.get(app);
@@ -19490,8 +19993,8 @@ var DASHBOARD_SCRYPT_KEYLEN = 64;
 var DASHBOARD_SCRYPT_COST = 1 << 15;
 var DASHBOARD_SCRYPT_MAXMEM = 64 * 1024 * 1024;
 function hashDashboardPassword(password) {
-  const salt = crypto26.randomBytes(16);
-  const derived = crypto26.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
+  const salt = crypto27.randomBytes(16);
+  const derived = crypto27.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
     N: DASHBOARD_SCRYPT_COST,
     maxmem: DASHBOARD_SCRYPT_MAXMEM
   });
@@ -19512,14 +20015,14 @@ function verifyDashboardPassword(password, storedHash) {
     } catch {
       return { ok: false, needsRehash: false };
     }
-    const derived = crypto26.scryptSync(password, salt, expected.length, {
+    const derived = crypto27.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: crypto26.timingSafeEqual(derived, expected),
+      ok: crypto27.timingSafeEqual(derived, expected),
       needsRehash: false
     };
   }
@@ -19528,7 +20031,7 @@ function verifyDashboardPassword(password, storedHash) {
     const expected = Buffer.from(storedHash, "hex");
     if (candidate.length !== expected.length)
       return { ok: false, needsRehash: false };
-    const ok = crypto26.timingSafeEqual(candidate, expected);
+    const ok = crypto27.timingSafeEqual(candidate, expected);
     return { ok, needsRehash: ok };
   }
   return { ok: false, needsRehash: false };
@@ -19575,7 +20078,7 @@ function applyLegacyCredentials(rows, config, persistConfigPatch = saveConfigPat
   }
   if (migratedGoogle > 0) {
     persistConfigPatch({ google: config.google });
-    log28.info("credentials.migrated", { type: "google", count: migratedGoogle });
+    log29.info("credentials.migrated", { type: "google", count: migratedGoogle });
   }
   let migratedGa4 = 0;
   for (const row of rows.ga4) {
@@ -19593,7 +20096,7 @@ function applyLegacyCredentials(rows, config, persistConfigPatch = saveConfigPat
   }
   if (migratedGa4 > 0) {
     persistConfigPatch({ ga4: config.ga4 });
-    log28.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
+    log29.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
   }
 }
 function isLoopbackPeerAddress(address) {
@@ -19695,7 +20198,7 @@ function cloneGtmConfig(config) {
 function createGoogleMarketingConfigCredentialStore(input) {
   const persistConfigPatch = input.saveConfigPatch ?? saveConfigPatch;
   const env = input.env ?? process.env;
-  const randomUUID2 = input.randomUUID ?? crypto26.randomUUID;
+  const randomUUID2 = input.randomUUID ?? crypto27.randomUUID;
   const snapshot = () => ({
     googleAds: cloneGoogleAdsConfig(input.config.googleAds),
     gtm: cloneGtmConfig(input.config.gtm)
@@ -19812,7 +20315,7 @@ async function createServer(opts) {
   const trustProxy = resolveTrustProxy(process.env.CANONRY_TRUST_PROXY);
   const app = Fastify({
     loggerInstance: logger,
-    genReqId: () => crypto26.randomUUID(),
+    genReqId: () => crypto27.randomUUID(),
     trustProxy
   });
   if (!ownsDefaultConfig) {
@@ -19876,17 +20379,17 @@ async function createServer(opts) {
       applyLegacyCredentials(legacyRows, opts.config, persistConfigPatch);
       dropLegacyCredentialColumns(opts.db);
     } catch (err) {
-      log28.warn("credentials.migration.failed", {
+      log29.warn("credentials.migration.failed", {
         error: describeError(err)
       });
     }
   }
-  log28.info("providers.configured", {
+  log29.info("providers.configured", {
     providers: registeredProviderNames({ providers, cdp: opts.config.cdp })
   });
   registry.replace(configuredProviderEntries(opts.config, API_ADAPTERS, cdpChatgptAdapter));
   for (const name of providersWithUnsupportedBatch(providers, (provider) => adapterMap[provider])) {
-    log28.warn("provider.batch.unsupported", {
+    log29.warn("provider.batch.unsupported", {
       provider: name,
       message: `providers.${name}.batch.enabled is true, but the ${name} adapter has no batch API; its sweeps run sync.`
     });
@@ -19943,7 +20446,7 @@ async function createServer(opts) {
     async (ctx) => {
       if (!sessionRegistry) return;
       if (!agentProactive) return;
-      const project = opts.db.select({ name: projects.name }).from(projects).where(eq34(projects.id, ctx.projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq35(projects.id, ctx.projectId)).get();
       if (!project) return;
       let content;
       if (ctx.kind === RunKinds["aeo-discover-probe"]) {
@@ -20417,7 +20920,7 @@ async function createServer(opts) {
       void (async () => {
         try {
           const report = await schedulerClient.runDoctor({ project: projectName, checkIds: scheduledHealthCheckIds() });
-          const project = opts.db.select().from(projects).where(eq34(projects.name, projectName)).get();
+          const project = opts.db.select().from(projects).where(eq35(projects.name, projectName)).get();
           if (!project) {
             app.log.warn({ projectName }, "doctor schedule fired for an unknown project");
             return;
@@ -20611,7 +21114,7 @@ async function createServer(opts) {
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto26.randomBytes(32).toString("hex");
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto27.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
@@ -20709,11 +21212,11 @@ async function createServer(opts) {
   })();
   if (opts.config.apiKey) {
     const keyHash = hashApiKey(opts.config.apiKey);
-    const existing = opts.db.select().from(apiKeys).where(eq34(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq35(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto26.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto27.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -20728,14 +21231,14 @@ async function createServer(opts) {
   );
   const currentPasswordFingerprint = () => hashSessionToken(opts.config.dashboardPasswordHash ?? "");
   opts.db.delete(dashboardSessions).where(or4(
-    eq34(dashboardSessions.apiKeyHash, ""),
-    and28(
+    eq35(dashboardSessions.apiKeyHash, ""),
+    and29(
       isNotNull5(dashboardSessions.passwordFingerprint),
       ne4(dashboardSessions.passwordFingerprint, currentPasswordFingerprint())
     )
   )).run();
   if (!opts.config.dashboardPasswordHash) {
-    const lastPasswordEventAt = (action) => opts.db.select({ at: max(auditLog.createdAt) }).from(auditLog).where(and28(eq34(auditLog.entityType, "dashboard-password"), eq34(auditLog.action, action))).get()?.at ?? null;
+    const lastPasswordEventAt = (action) => opts.db.select({ at: max(auditLog.createdAt) }).from(auditLog).where(and29(eq35(auditLog.entityType, "dashboard-password"), eq35(auditLog.action, action))).get()?.at ?? null;
     const createdAt = lastPasswordEventAt("dashboard-password.created");
     const clearedAt = lastPasswordEventAt("dashboard-password.cleared");
     if (createdAt !== null && (clearedAt === null || clearedAt < createdAt)) {
@@ -20750,7 +21253,7 @@ async function createServer(opts) {
   const createSession = (key, passwordBased = false, db = opts.db) => {
     const now = /* @__PURE__ */ new Date();
     db.delete(dashboardSessions).where(lte3(dashboardSessions.expiresAt, now.toISOString())).run();
-    const sessionId = crypto26.randomBytes(32).toString("hex");
+    const sessionId = crypto27.randomBytes(32).toString("hex");
     db.insert(dashboardSessions).values({
       tokenHash: hashSessionToken(sessionId),
       apiKeyId: key.id,
@@ -20769,23 +21272,23 @@ async function createServer(opts) {
       currentApiKeyHash: apiKeys.keyHash,
       passwordFingerprint: dashboardSessions.passwordFingerprint,
       expiresAt: dashboardSessions.expiresAt
-    }).from(dashboardSessions).innerJoin(apiKeys, eq34(apiKeys.id, dashboardSessions.apiKeyId)).where(and28(eq34(dashboardSessions.tokenHash, tokenHash), isNull8(apiKeys.revokedAt))).get();
+    }).from(dashboardSessions).innerJoin(apiKeys, eq35(apiKeys.id, dashboardSessions.apiKeyId)).where(and29(eq35(dashboardSessions.tokenHash, tokenHash), isNull8(apiKeys.revokedAt))).get();
     if (!session) return null;
     const expiresAt = Date.parse(session.expiresAt);
     if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() || session.apiKeyHash !== session.currentApiKeyHash || session.passwordFingerprint !== null && session.passwordFingerprint !== currentPasswordFingerprint()) {
-      opts.db.delete(dashboardSessions).where(eq34(dashboardSessions.tokenHash, tokenHash)).run();
+      opts.db.delete(dashboardSessions).where(eq35(dashboardSessions.tokenHash, tokenHash)).run();
       return null;
     }
     return session.apiKeyId;
   };
   const clearSession = (sessionId) => {
     if (sessionId) {
-      opts.db.delete(dashboardSessions).where(eq34(dashboardSessions.tokenHash, hashSessionToken(sessionId))).run();
+      opts.db.delete(dashboardSessions).where(eq35(dashboardSessions.tokenHash, hashSessionToken(sessionId))).run();
     }
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq34(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq35(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const setSessionCookie = (reply, sessionId) => {
     reply.header(
@@ -20814,7 +21317,7 @@ async function createServer(opts) {
     if (parts.length !== 2 || parts[0] !== "Bearer" || !parts[1]) return false;
     const presented = Buffer.from(hashApiKey(parts[1]), "hex");
     const expected = Buffer.from(key.keyHash, "hex");
-    return presented.length === expected.length && crypto26.timingSafeEqual(presented, expected);
+    return presented.length === expected.length && crypto27.timingSafeEqual(presented, expected);
   };
   const namedAccountsInUse = () => anyUsersExist(opts.db);
   const NAMED_ACCOUNTS_MESSAGE = "This install uses named accounts. Sign in with your name and password.";
@@ -20946,12 +21449,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq34(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq35(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(eq34(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq35(apiKeys.id, key.id)).run();
       setSessionCookie(reply, createSession(key));
       return reply.send({ authenticated: true });
     }
@@ -21017,7 +21520,7 @@ async function createServer(opts) {
   const sentimentPoller = createSentimentPoller(
     () => sentimentWorker.tick(),
     () => {
-      log28.error("sentiment.worker-failed", { reason: "Stored sentiment worker could not finish its tick." });
+      log29.error("sentiment.worker-failed", { reason: "Stored sentiment worker could not finish its tick." });
     }
   );
   const pollSentiment = sentimentPoller.poll;
@@ -21029,7 +21532,7 @@ async function createServer(opts) {
   const recomputeDebts = /* @__PURE__ */ new Map();
   let recomputeSequence = 0;
   const markAnswerFieldRecompute = (projectId, full) => {
-    opts.db.update(projects).set({ answerFieldsRecompute: full ? "full" : sql14`CASE WHEN ${projects.answerFieldsRecompute} = 'full' THEN 'full' ELSE 'competitors' END` }).where(eq34(projects.id, projectId)).run();
+    opts.db.update(projects).set({ answerFieldsRecompute: full ? "full" : sql15`CASE WHEN ${projects.answerFieldsRecompute} = 'full' THEN 'full' ELSE 'competitors' END` }).where(eq35(projects.id, projectId)).run();
   };
   const requestAnswerFieldRecompute = (projectId, projectName, scope, reason) => {
     const sequence = ++recomputeSequence;
@@ -21047,10 +21550,10 @@ async function createServer(opts) {
         if (pass.full && debt.latestFull <= sequence) debt.latestFull = 0;
         try {
           if (debt.latest === sequence && debt.latestFull === 0) {
-            opts.db.update(projects).set({ answerFieldsRecompute: null }).where(eq34(projects.id, projectId)).run();
+            opts.db.update(projects).set({ answerFieldsRecompute: null }).where(eq35(projects.id, projectId)).run();
             if (recomputeDebts.get(projectId) === debt) recomputeDebts.delete(projectId);
           } else if (debt.latestFull === 0) {
-            opts.db.update(projects).set({ answerFieldsRecompute: "competitors" }).where(and28(eq34(projects.id, projectId), eq34(projects.answerFieldsRecompute, "full"))).run();
+            opts.db.update(projects).set({ answerFieldsRecompute: "competitors" }).where(and29(eq35(projects.id, projectId), eq35(projects.answerFieldsRecompute, "full"))).run();
           }
         } catch (err) {
           app.log.error({ err, projectId }, "could not clear the owed answer field recompute");
@@ -21087,7 +21590,7 @@ async function createServer(opts) {
     await yieldToEventLoop4();
     const reason = (competitorAutoAliasReasons.get(projectId) ?? []).join(",");
     competitorAutoAliasReasons.delete(projectId);
-    const project = opts.db.select().from(projects).where(eq34(projects.id, projectId)).get();
+    const project = opts.db.select().from(projects).where(eq35(projects.id, projectId)).get();
     if (!project || project.competitorAutoAliases === "off") return;
     if (project.competitorAutoAliases === "apply") {
       await competitorAutoAliases.request(projectId, reason).catch(() => void 0);
@@ -21287,8 +21790,8 @@ async function createServer(opts) {
     getAgentPin: () => describeAgentPin(opts.config),
     getGoogleMarketingDoctorInput: (ctx) => {
       if (!ctx.project) return null;
-      const googleAds = opts.db.select().from(googleAdsConnections).where(eq34(googleAdsConnections.projectId, ctx.project.id)).get();
-      const gtm = opts.db.select().from(gtmConnections).where(eq34(gtmConnections.projectId, ctx.project.id)).get();
+      const googleAds = opts.db.select().from(googleAdsConnections).where(eq35(googleAdsConnections.projectId, ctx.project.id)).get();
+      const gtm = opts.db.select().from(gtmConnections).where(eq35(gtmConnections.projectId, ctx.project.id)).get();
       const googleAdsCredential = getGoogleAdsConnection(opts.config, ctx.project.id);
       const gtmCredential = getGtmConnection(opts.config, ctx.project.id);
       const googleAdsConnected = Boolean(googleAdsCredential?.accessToken);
@@ -21417,7 +21920,7 @@ async function createServer(opts) {
         deps: {
           enqueueAutoExtract: ({ projectId, release: r }) => {
             const now = (/* @__PURE__ */ new Date()).toISOString();
-            const runId = crypto26.randomUUID();
+            const runId = crypto27.randomUUID();
             opts.db.insert(runs).values({
               id: runId,
               projectId,
@@ -21538,7 +22041,7 @@ async function createServer(opts) {
         ...inspectOpts,
         config: opts.config
       }).then(() => {
-        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq34(runs.id, runId)).get();
+        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq35(runs.id, runId)).get();
         if (finished?.status === RunStatuses.completed || finished?.status === RunStatuses.partial) {
           return maybeRefreshGscCoverage(
             opts.db,
@@ -21554,6 +22057,13 @@ async function createServer(opts) {
         app.log.error({ runId, err }, "Bing inspect sitemap failed");
       });
     },
+    onBingSyncRequested: (runId, projectId) => {
+      executeBingSync(opts.db, runId, projectId, { config: opts.config }).catch(
+        (err) => {
+          app.log.error({ runId, err }, "Bing sync failed");
+        }
+      );
+    },
     wordpressConnectionStore,
     ga4CredentialStore,
     cloudRunCredentialStore,
@@ -21784,7 +22294,7 @@ async function createServer(opts) {
         }
       ];
     },
-    onGenerateQueries: async (providerName, count5, project) => {
+    onGenerateQueries: async (providerName, count6, project) => {
       const provider = registry.get(providerName);
       if (!provider)
         throw new Error(`Provider "${providerName}" is not configured`);
@@ -21798,10 +22308,10 @@ async function createServer(opts) {
         language: project.language,
         existingQueries: project.existingQueries,
         siteText,
-        count: count5
+        count: count6
       });
       const raw = await provider.adapter.generateText(prompt, provider.config);
-      return parseQueryResponse(raw, count5);
+      return parseQueryResponse(raw, count6);
     },
     onSnapshotRequested: async (input) => {
       return snapshotService.createReport(input);
@@ -22039,7 +22549,7 @@ async function createServer(opts) {
           isBacklinksInstalled: () => isDuckdbInstalled()
         });
       }
-      for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq34(researchRuns.status, ResearchRunStatuses.queued)).all()) {
+      for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq35(researchRuns.status, ResearchRunStatuses.queued)).all()) {
         dispatchResearchRun(run.id, run.projectId, OutcomeTriggers.startup);
       }
       runtimeStartupSettled = true;
@@ -22104,7 +22614,7 @@ function buildQueryGenerationPrompt(ctx) {
   );
   return lines.join("\n");
 }
-function parseQueryResponse(raw, count5) {
+function parseQueryResponse(raw, count6) {
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const line of raw.split("\n")) {
@@ -22120,7 +22630,7 @@ function parseQueryResponse(raw, count5) {
     if (seen.has(key)) continue;
     seen.add(key);
     results.push(cleaned);
-    if (results.length >= count5) break;
+    if (results.length >= count6) break;
   }
   return results;
 }