@canonry/canonry 4.148.7 → 4.148.11

package/dist/{chunk-4VNOYFCG.js → chunk-U2ETSHDL.js}

@@ -549,11 +549,11 @@ function checkLatestVersionForServer(opts) {
 
 // src/server.ts
 import { createRequire as createRequire3 } from "module";
-import crypto22 from "crypto";
+import crypto23 from "crypto";
 import fs8 from "fs";
 import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { and as and15, eq as eq21 } from "drizzle-orm";
+import { and as and15, eq as eq22 } from "drizzle-orm";
 import Fastify from "fastify";
 import os5 from "os";
 
@@ -4225,8 +4225,83 @@ function maybeShowActivationNotice(io = {}) {
 }
 
 // src/gsc-sync.ts
+import crypto6 from "crypto";
+import { eq as eq4, and as and4, sql as sql3 } from "drizzle-orm";
+
+// src/gsc-coverage-snapshot.ts
 import crypto5 from "crypto";
-import { eq as eq3, and as and3, sql as sql3 } from "drizzle-orm";
+import { and as and3, desc, eq as eq3, gte } from "drizzle-orm";
+var COVERAGE_IMPRESSION_WINDOW_DAYS = 30;
+function pageKey(raw) {
+  if (!raw) return null;
+  try {
+    return normalizeUrlPath(new URL(raw).pathname);
+  } catch {
+    return normalizeUrlPath(raw);
+  }
+}
+function isoDaysAgo(days) {
+  const d = /* @__PURE__ */ new Date();
+  d.setUTCDate(d.getUTCDate() - days);
+  return d.toISOString().split("T")[0];
+}
+function writeCoverageSnapshot(db, projectId, runId, opts = {}) {
+  const windowDays = opts.windowDays ?? COVERAGE_IMPRESSION_WINDOW_DAYS;
+  const since = isoDaysAgo(windowDays);
+  const pageRows = db.select({ page: gscSearchData.page, impressions: gscSearchData.impressions }).from(gscSearchData).where(and3(eq3(gscSearchData.projectId, projectId), gte(gscSearchData.date, since))).all();
+  const allInspections = db.select().from(gscUrlInspections).where(eq3(gscUrlInspections.projectId, projectId)).all();
+  const latestAudit = db.select({ runId: siteAuditSnapshots.runId }).from(siteAuditSnapshots).where(eq3(siteAuditSnapshots.projectId, projectId)).orderBy(desc(siteAuditSnapshots.createdAt)).limit(1).get();
+  const sitemapUrls = latestAudit ? db.select({ url: siteAuditPages.url }).from(siteAuditPages).where(eq3(siteAuditPages.runId, latestAudit.runId)).all() : [];
+  const impressionsByKey = /* @__PURE__ */ new Map();
+  for (const row of pageRows) {
+    const key = pageKey(row.page);
+    if (key) impressionsByKey.set(key, (impressionsByKey.get(key) ?? 0) + row.impressions);
+  }
+  for (const row of sitemapUrls) {
+    const key = pageKey(row.url);
+    if (key && !impressionsByKey.has(key)) impressionsByKey.set(key, 0);
+  }
+  const latestByKey = /* @__PURE__ */ new Map();
+  for (const row of allInspections) {
+    const key = pageKey(row.url);
+    if (!key) continue;
+    const existing = latestByKey.get(key);
+    if (!existing || row.inspectedAt > existing.inspectedAt) latestByKey.set(key, row);
+  }
+  const coverage = deriveIndexCoverage({
+    pages: [...impressionsByKey].map(([page, impressions]) => ({ page, impressions })),
+    inspections: [...latestByKey].map(([key, r]) => ({
+      url: key,
+      indexingState: r.indexingState,
+      coverageState: r.coverageState
+    }))
+  });
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const snapshotDate = now.toISOString().split("T")[0];
+  db.delete(gscCoverageSnapshots).where(and3(eq3(gscCoverageSnapshots.projectId, projectId), eq3(gscCoverageSnapshots.date, snapshotDate))).run();
+  db.insert(gscCoverageSnapshots).values({
+    id: crypto5.randomUUID(),
+    projectId,
+    syncRunId: runId,
+    date: snapshotDate,
+    indexed: coverage.indexed,
+    notIndexed: coverage.notIndexed,
+    unknownPages: coverage.unknown,
+    verifiedByInspection: coverage.verifiedByInspection,
+    derivedFromImpressions: coverage.derivedFromImpressions,
+    reasonBreakdown: coverage.reasonBreakdown,
+    createdAt: now.toISOString()
+  }).run();
+  return {
+    indexed: coverage.indexed,
+    notIndexed: coverage.notIndexed,
+    unknown: coverage.unknown,
+    verifiedByInspection: coverage.verifiedByInspection,
+    derivedFromImpressions: coverage.derivedFromImpressions
+  };
+}
+
+// src/gsc-sync.ts
 var log2 = createLogger("GscSync");
 function formatDate(d) {
   return d.toISOString().split("T")[0];
@@ -4238,13 +4313,13 @@ function daysAgo(n) {
 }
 async function executeGscSync(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq3(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq4(runs.id, runId)).run();
   try {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getGoogleAuthConfig(opts.config);
     if (!googleClientId || !googleClientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq3(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq4(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -4279,8 +4354,8 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     log2.info("fetch.complete", { runId, projectId, rowCount: rows.length });
     db.delete(gscSearchData).where(
-      and3(
-        eq3(gscSearchData.projectId, projectId),
+      and4(
+        eq4(gscSearchData.projectId, projectId),
         sql3`${gscSearchData.date} >= ${startDate}`,
         sql3`${gscSearchData.date} <= ${endDate}`
       )
@@ -4292,7 +4367,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       for (const row of batch) {
         const [query, page, country, device, date] = row.keys;
         db.insert(gscSearchData).values({
-          id: crypto5.randomUUID(),
+          id: crypto6.randomUUID(),
           projectId,
           syncRunId: runId,
           date: date ?? "",
@@ -4314,8 +4389,8 @@ async function executeGscSync(db, runId, projectId, opts) {
       dimensions: ["date"]
     });
     db.delete(gscDailyTotals).where(
-      and3(
-        eq3(gscDailyTotals.projectId, projectId),
+      and4(
+        eq4(gscDailyTotals.projectId, projectId),
         sql3`${gscDailyTotals.date} >= ${startDate}`,
         sql3`${gscDailyTotals.date} <= ${endDate}`
       )
@@ -4324,7 +4399,7 @@ async function executeGscSync(db, runId, projectId, opts) {
     for (const row of totalRows) {
       const [date] = row.keys;
       db.insert(gscDailyTotals).values({
-        id: crypto5.randomUUID(),
+        id: crypto6.randomUUID(),
         projectId,
         date: date ?? "",
         clicks: row.clicks,
@@ -4340,8 +4415,8 @@ async function executeGscSync(db, runId, projectId, opts) {
       dimensions: ["date", "query"]
     });
     db.delete(gscQueryDailyTotals).where(
-      and3(
-        eq3(gscQueryDailyTotals.projectId, projectId),
+      and4(
+        eq4(gscQueryDailyTotals.projectId, projectId),
         sql3`${gscQueryDailyTotals.date} >= ${startDate}`,
         sql3`${gscQueryDailyTotals.date} <= ${endDate}`
       )
@@ -4351,7 +4426,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       const [date, query] = row.keys;
       if (!date || !query) continue;
       db.insert(gscQueryDailyTotals).values({
-        id: crypto5.randomUUID(),
+        id: crypto6.randomUUID(),
         projectId,
         date,
         query,
@@ -4364,50 +4439,20 @@ async function executeGscSync(db, runId, projectId, opts) {
       }).run();
     }
     log2.info("query-totals.complete", { runId, projectId, rowCount: queryTotalRows.length });
-    const allInspections = db.select().from(gscUrlInspections).where(eq3(gscUrlInspections.projectId, projectId)).all();
-    const latestByUrl = /* @__PURE__ */ new Map();
-    for (const row of allInspections) {
-      const existing = latestByUrl.get(row.url);
-      if (!existing || row.inspectedAt > existing.inspectedAt) {
-        latestByUrl.set(row.url, row);
-      }
-    }
-    const coverage = deriveIndexCoverage({
-      pages: rows.map((row) => ({ page: row.keys[1] ?? "", impressions: row.impressions })),
-      inspections: [...latestByUrl.values()].map((row) => ({
-        url: row.url,
-        indexingState: row.indexingState,
-        coverageState: row.coverageState
-      }))
-    });
-    const snapshotDate = formatDate(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and3(eq3(gscCoverageSnapshots.projectId, projectId), eq3(gscCoverageSnapshots.date, snapshotDate))).run();
-    db.insert(gscCoverageSnapshots).values({
-      id: crypto5.randomUUID(),
-      projectId,
-      syncRunId: runId,
-      date: snapshotDate,
-      indexed: coverage.indexed,
-      notIndexed: coverage.notIndexed,
-      unknownPages: coverage.unknown,
-      verifiedByInspection: coverage.verifiedByInspection,
-      derivedFromImpressions: coverage.derivedFromImpressions,
-      reasonBreakdown: coverage.reasonBreakdown,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).run();
-    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq3(runs.id, runId)).run();
+    const coverage = writeCoverageSnapshot(db, projectId, runId);
+    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
     log2.info("sync.completed", { runId, projectId, searchDataRows: rows.length, indexed: coverage.indexed, notIndexed: coverage.notIndexed, unknown: coverage.unknown, verifiedByInspection: coverage.verifiedByInspection });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq3(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
     log2.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/gbp-sync.ts
-import crypto6 from "crypto";
-import { eq as eq4, and as and4, desc, inArray as inArray2, lt } from "drizzle-orm";
+import crypto7 from "crypto";
+import { eq as eq5, and as and5, desc as desc2, inArray as inArray2, lt } from "drizzle-orm";
 var MS_PER_DAY = 864e5;
 var log3 = createLogger("GbpSync");
 var LOCATION_CONCURRENCY = 4;
@@ -4428,13 +4473,13 @@ function monthMinus(n) {
 }
 async function executeGbpSync(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq4(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq5(runs.id, runId)).run();
   try {
     const { clientId, clientSecret } = getGoogleAuthConfig(opts.config);
     if (!clientId || !clientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq4(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq5(projects.id, projectId)).get();
     if (!project) throw new Error(`Project not found: ${projectId}`);
     const conn = getGoogleConnection(opts.config, project.canonicalDomain, "gbp");
     if (!conn || !conn.refreshToken) {
@@ -4452,7 +4497,7 @@ async function executeGbpSync(db, runId, projectId, opts) {
       });
       saveConfigPatch(opts.config);
     }
-    let locationRows = db.select().from(gbpLocations).where(and4(eq4(gbpLocations.projectId, projectId), eq4(gbpLocations.selected, true))).all();
+    let locationRows = db.select().from(gbpLocations).where(and5(eq5(gbpLocations.projectId, projectId), eq5(gbpLocations.selected, true))).all();
     if (opts.locationNames?.length) {
       const wanted = new Set(opts.locationNames);
       locationRows = locationRows.filter((l) => wanted.has(l.locationName));
@@ -4502,15 +4547,15 @@ async function executeGbpSync(db, runId, projectId, opts) {
             })))
           ]);
           const lodgingHash = lodging ? hashLodging(lodging) : null;
-          const latestLodging = lodging ? db.select().from(gbpLodgingSnapshots).where(and4(eq4(gbpLodgingSnapshots.projectId, projectId), eq4(gbpLodgingSnapshots.locationName, loc.locationName))).orderBy(desc(gbpLodgingSnapshots.syncedAt)).limit(1).get() : void 0;
+          const latestLodging = lodging ? db.select().from(gbpLodgingSnapshots).where(and5(eq5(gbpLodgingSnapshots.projectId, projectId), eq5(gbpLodgingSnapshots.locationName, loc.locationName))).orderBy(desc2(gbpLodgingSnapshots.syncedAt)).limit(1).get() : void 0;
           const lodgingChanged = lodging !== null && latestLodging?.contentHash !== lodgingHash;
           const attributesHash = hashAttributes(attributes);
-          const latestAttributes = db.select().from(gbpAttributesSnapshots).where(and4(eq4(gbpAttributesSnapshots.projectId, projectId), eq4(gbpAttributesSnapshots.locationName, loc.locationName))).orderBy(desc(gbpAttributesSnapshots.syncedAt)).limit(1).get();
+          const latestAttributes = db.select().from(gbpAttributesSnapshots).where(and5(eq5(gbpAttributesSnapshots.projectId, projectId), eq5(gbpAttributesSnapshots.locationName, loc.locationName))).orderBy(desc2(gbpAttributesSnapshots.syncedAt)).limit(1).get();
           const attributesChanged = latestAttributes?.contentHash !== attributesHash;
           let placeToWrite = null;
           let placeToTouch = null;
           if (placesTier !== "off" && placesApiKey && lodging !== null && loc.placeId) {
-            const latestPlace = db.select().from(gbpPlaceDetails).where(and4(eq4(gbpPlaceDetails.projectId, projectId), eq4(gbpPlaceDetails.locationName, loc.locationName))).orderBy(desc(gbpPlaceDetails.syncedAt)).limit(1).get();
+            const latestPlace = db.select().from(gbpPlaceDetails).where(and5(eq5(gbpPlaceDetails.projectId, projectId), eq5(gbpPlaceDetails.locationName, loc.locationName))).orderBy(desc2(gbpPlaceDetails.syncedAt)).limit(1).get();
             const ageDays = latestPlace ? (Date.now() - new Date(latestPlace.syncedAt).getTime()) / MS_PER_DAY : Infinity;
             if (ageDays >= placesRefreshDays) {
               try {
@@ -4528,10 +4573,10 @@ async function executeGbpSync(db, runId, projectId, opts) {
           }
           const insertNow = (/* @__PURE__ */ new Date()).toISOString();
           db.transaction((tx) => {
-            tx.delete(gbpDailyMetrics).where(and4(eq4(gbpDailyMetrics.projectId, projectId), eq4(gbpDailyMetrics.locationName, loc.locationName))).run();
+            tx.delete(gbpDailyMetrics).where(and5(eq5(gbpDailyMetrics.projectId, projectId), eq5(gbpDailyMetrics.locationName, loc.locationName))).run();
             for (const row of metricRows) {
               tx.insert(gbpDailyMetrics).values({
-                id: crypto6.randomUUID(),
+                id: crypto7.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 date: row.date,
@@ -4540,10 +4585,10 @@ async function executeGbpSync(db, runId, projectId, opts) {
                 syncRunId: runId
               }).run();
             }
-            tx.delete(gbpKeywordImpressions).where(and4(eq4(gbpKeywordImpressions.projectId, projectId), eq4(gbpKeywordImpressions.locationName, loc.locationName))).run();
+            tx.delete(gbpKeywordImpressions).where(and5(eq5(gbpKeywordImpressions.projectId, projectId), eq5(gbpKeywordImpressions.locationName, loc.locationName))).run();
             for (const row of keywordRows) {
               tx.insert(gbpKeywordImpressions).values({
-                id: crypto6.randomUUID(),
+                id: crypto7.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 periodStart: monthKey(keywordsStart),
@@ -4556,15 +4601,15 @@ async function executeGbpSync(db, runId, projectId, opts) {
             }
             const fetchedMonths = monthlyKeywordResults.map((r) => r.month);
             if (fetchedMonths.length > 0) {
-              tx.delete(gbpKeywordMonthly).where(and4(
-                eq4(gbpKeywordMonthly.projectId, projectId),
-                eq4(gbpKeywordMonthly.locationName, loc.locationName),
+              tx.delete(gbpKeywordMonthly).where(and5(
+                eq5(gbpKeywordMonthly.projectId, projectId),
+                eq5(gbpKeywordMonthly.locationName, loc.locationName),
                 inArray2(gbpKeywordMonthly.month, fetchedMonths)
               )).run();
               for (const { month, rows } of monthlyKeywordResults) {
                 for (const row of rows) {
                   tx.insert(gbpKeywordMonthly).values({
-                    id: crypto6.randomUUID(),
+                    id: crypto7.randomUUID(),
                     projectId,
                     locationName: loc.locationName,
                     month,
@@ -4576,16 +4621,16 @@ async function executeGbpSync(db, runId, projectId, opts) {
                   }).run();
                 }
               }
-              tx.delete(gbpKeywordMonthly).where(and4(
-                eq4(gbpKeywordMonthly.projectId, projectId),
-                eq4(gbpKeywordMonthly.locationName, loc.locationName),
+              tx.delete(gbpKeywordMonthly).where(and5(
+                eq5(gbpKeywordMonthly.projectId, projectId),
+                eq5(gbpKeywordMonthly.locationName, loc.locationName),
                 lt(gbpKeywordMonthly.month, keywordRetentionCutoff)
               )).run();
             }
-            tx.delete(gbpPlaceActions).where(and4(eq4(gbpPlaceActions.projectId, projectId), eq4(gbpPlaceActions.locationName, loc.locationName))).run();
+            tx.delete(gbpPlaceActions).where(and5(eq5(gbpPlaceActions.projectId, projectId), eq5(gbpPlaceActions.locationName, loc.locationName))).run();
             for (const row of placeActionRows) {
               tx.insert(gbpPlaceActions).values({
-                id: crypto6.randomUUID(),
+                id: crypto7.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 placeActionLinkName: row.placeActionLinkName,
@@ -4598,7 +4643,7 @@ async function executeGbpSync(db, runId, projectId, opts) {
             }
             if (lodging !== null && lodgingChanged) {
               tx.insert(gbpLodgingSnapshots).values({
-                id: crypto6.randomUUID(),
+                id: crypto7.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 contentHash: lodgingHash,
@@ -4608,11 +4653,11 @@ async function executeGbpSync(db, runId, projectId, opts) {
                 syncRunId: runId
               }).run();
             } else if (lodging !== null && latestLodging) {
-              tx.update(gbpLodgingSnapshots).set({ syncedAt: insertNow, syncRunId: runId }).where(eq4(gbpLodgingSnapshots.id, latestLodging.id)).run();
+              tx.update(gbpLodgingSnapshots).set({ syncedAt: insertNow, syncRunId: runId }).where(eq5(gbpLodgingSnapshots.id, latestLodging.id)).run();
             }
             if (attributesChanged) {
               tx.insert(gbpAttributesSnapshots).values({
-                id: crypto6.randomUUID(),
+                id: crypto7.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 contentHash: attributesHash,
@@ -4622,11 +4667,11 @@ async function executeGbpSync(db, runId, projectId, opts) {
                 syncRunId: runId
               }).run();
             } else if (latestAttributes) {
-              tx.update(gbpAttributesSnapshots).set({ syncedAt: insertNow, syncRunId: runId }).where(eq4(gbpAttributesSnapshots.id, latestAttributes.id)).run();
+              tx.update(gbpAttributesSnapshots).set({ syncedAt: insertNow, syncRunId: runId }).where(eq5(gbpAttributesSnapshots.id, latestAttributes.id)).run();
             }
             if (placeToWrite) {
               tx.insert(gbpPlaceDetails).values({
-                id: crypto6.randomUUID(),
+                id: crypto7.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 placeId: placeToWrite.placeId,
@@ -4637,9 +4682,9 @@ async function executeGbpSync(db, runId, projectId, opts) {
                 syncRunId: runId
               }).run();
             } else if (placeToTouch) {
-              tx.update(gbpPlaceDetails).set({ syncedAt: insertNow, syncRunId: runId }).where(eq4(gbpPlaceDetails.id, placeToTouch)).run();
+              tx.update(gbpPlaceDetails).set({ syncedAt: insertNow, syncRunId: runId }).where(eq5(gbpPlaceDetails.id, placeToTouch)).run();
             }
-            tx.update(gbpLocations).set({ syncedAt: insertNow, updatedAt: insertNow }).where(eq4(gbpLocations.id, loc.id)).run();
+            tx.update(gbpLocations).set({ syncedAt: insertNow, updatedAt: insertNow }).where(eq5(gbpLocations.id, loc.id)).run();
           });
           okCount++;
         } catch (err) {
@@ -4650,24 +4695,24 @@ async function executeGbpSync(db, runId, projectId, opts) {
     }
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (errors.size === 0) {
-      db.update(runs).set({ status: "completed", finishedAt }).where(eq4(runs.id, runId)).run();
+      db.update(runs).set({ status: "completed", finishedAt }).where(eq5(runs.id, runId)).run();
     } else if (okCount > 0) {
       db.update(runs).set({
         status: "partial",
         error: serializeRunError(buildRunErrorFromMessages(errors)),
         finishedAt
-      }).where(eq4(runs.id, runId)).run();
+      }).where(eq5(runs.id, runId)).run();
     } else {
       db.update(runs).set({
         status: "failed",
         error: serializeRunError(buildRunErrorFromMessages(errors)),
         finishedAt
-      }).where(eq4(runs.id, runId)).run();
+      }).where(eq5(runs.id, runId)).run();
     }
     log3.info("sync.done", { runId, projectId, ok: okCount, failed: errors.size });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
     log3.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -4705,7 +4750,7 @@ async function refreshSelectedLocationProfiles(db, projectId, accessToken, locat
         ...profile,
         updatedAt
       };
-      db.update(gbpLocations).set(update).where(and4(eq4(gbpLocations.projectId, projectId), eq4(gbpLocations.id, row.id))).run();
+      db.update(gbpLocations).set(update).where(and5(eq5(gbpLocations.projectId, projectId), eq5(gbpLocations.id, row.id))).run();
       refreshedRows.set(row.id, { ...row, ...update });
     }
   }
@@ -4713,8 +4758,8 @@ async function refreshSelectedLocationProfiles(db, projectId, accessToken, locat
 }
 
 // src/ads-sync.ts
-import crypto7 from "crypto";
-import { eq as eq5 } from "drizzle-orm";
+import crypto8 from "crypto";
+import { eq as eq6 } from "drizzle-orm";
 
 // ../integration-openai-ads/src/constants.ts
 var OPENAI_ADS_API_BASE = "https://api.ads.openai.com/v1";
@@ -5322,11 +5367,11 @@ function toDailyUpserts(level, entityId, read) {
 }
 async function executeAdsSync(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq5(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq6(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq5(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq6(projects.id, projectId)).get();
     if (!project) throw new Error(`Project not found: ${projectId}`);
-    const connRow = db.select().from(adsConnections).where(eq5(adsConnections.projectId, projectId)).get();
+    const connRow = db.select().from(adsConnections).where(eq6(adsConnections.projectId, projectId)).get();
     if (!connRow) {
       throw new Error('No ads connection found for this project. Run "canonry ads connect" first.');
     }
@@ -5386,7 +5431,7 @@ async function executeAdsSync(db, runId, projectId, opts) {
     );
     const insertNow = (/* @__PURE__ */ new Date()).toISOString();
     db.transaction((tx) => {
-      tx.delete(adsCampaigns).where(eq5(adsCampaigns.projectId, projectId)).run();
+      tx.delete(adsCampaigns).where(eq6(adsCampaigns.projectId, projectId)).run();
       for (const campaign of syncedCampaigns) {
         tx.insert(adsCampaigns).values({
           id: campaign.id,
@@ -5441,7 +5486,7 @@ async function executeAdsSync(db, runId, projectId, opts) {
       }
       for (const upsert of insightUpserts) {
         tx.insert(adsInsightsDaily).values({
-          id: crypto7.randomUUID(),
+          id: crypto8.randomUUID(),
           projectId,
           level: upsert.level,
           entityId: upsert.entityId,
@@ -5480,36 +5525,36 @@ async function executeAdsSync(db, runId, projectId, opts) {
         conversionTrackingConfigured,
         lastSyncedAt: insertNow,
         updatedAt: insertNow
-      }).where(eq5(adsConnections.projectId, projectId)).run();
+      }).where(eq6(adsConnections.projectId, projectId)).run();
     });
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (errors.size === 0) {
-      db.update(runs).set({ status: "completed", finishedAt }).where(eq5(runs.id, runId)).run();
+      db.update(runs).set({ status: "completed", finishedAt }).where(eq6(runs.id, runId)).run();
     } else if (syncedCampaigns.length > 0) {
       db.update(runs).set({
         status: "partial",
         error: serializeRunError(buildRunErrorFromMessages(errors)),
         finishedAt
-      }).where(eq5(runs.id, runId)).run();
+      }).where(eq6(runs.id, runId)).run();
     } else {
       db.update(runs).set({
         status: "failed",
         error: serializeRunError(buildRunErrorFromMessages(errors)),
         finishedAt
-      }).where(eq5(runs.id, runId)).run();
+      }).where(eq6(runs.id, runId)).run();
     }
     log4.info("sync.done", { runId, projectId, campaigns: syncedCampaigns.length, insightRows: insightUpserts.length, failed: errors.size });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq6(runs.id, runId)).run();
     log4.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/gsc-inspect-sitemap.ts
-import crypto8 from "crypto";
-import { eq as eq6, and as and5 } from "drizzle-orm";
+import crypto9 from "crypto";
+import { eq as eq7 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var log5 = createLogger("SitemapParser");
@@ -5609,6 +5654,9 @@ async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
 
 // src/gsc-inspect-paced.ts
 var INSPECT_BASE_DELAY_MS = 1e3;
+var INSPECT_MAX_CONCURRENCY = 5;
+var INSPECT_DAILY_QUOTA = 2e3;
+var INSPECT_SWEEP_MAX_URLS = 1500;
 var INSPECT_PACING_JITTER_MS = 250;
 var INSPECT_MAX_RETRIES = 3;
 var INSPECT_MAX_BACKOFF_MS = 3e4;
@@ -5625,62 +5673,79 @@ function defaultSleep(ms) {
 async function inspectUrlsPaced(urls, cb, deps = {}) {
   const sleep3 = deps.sleep ?? defaultSleep;
   const jitter = deps.jitter ?? Math.random;
+  const concurrency = Math.max(1, Math.min(deps.concurrency ?? INSPECT_MAX_CONCURRENCY, urls.length || 1));
   let inspected = 0;
   let errors = 0;
   let consecutiveRetryableFailures = 0;
-  for (let index = 0; index < urls.length; index++) {
-    const url = urls[index];
-    try {
-      const result = await withRetry(() => cb.inspectOne(url), {
-        maxRetries: INSPECT_MAX_RETRIES,
-        baseDelayMs: INSPECT_BASE_DELAY_MS,
-        maxDelayMs: INSPECT_MAX_BACKOFF_MS,
-        isRetryable: isRetryableGscInspectError,
-        sleep: sleep3,
-        onRetry: ({ attempt, delayMs, err }) => deps.log?.info("inspect.retry", {
-          url,
-          attempt,
-          delayMs: Math.round(delayMs),
-          error: err instanceof Error ? err.message : String(err)
-        })
-      });
-      cb.onResult(url, result, index);
-      inspected++;
-      consecutiveRetryableFailures = 0;
-    } catch (err) {
-      errors++;
-      cb.onError(url, err, index);
-      if (isRetryableGscInspectError(err)) {
-        consecutiveRetryableFailures++;
-        if (consecutiveRetryableFailures >= INSPECT_FAILFAST_THRESHOLD) {
-          deps.log?.error("inspect.circuit-break", {
-            consecutiveFailures: consecutiveRetryableFailures,
-            inspected,
-            errors,
-            remaining: urls.length - index - 1
-          });
-          return { inspected, errors, aborted: true, abortError: err };
+  let nextIndex = 0;
+  let aborted = false;
+  let abortError;
+  let ratePromise = Promise.resolve();
+  const takeRateSlot = () => {
+    const wait = ratePromise.then(() => sleep3(INSPECT_BASE_DELAY_MS + jitter() * INSPECT_PACING_JITTER_MS));
+    ratePromise = wait;
+    return wait;
+  };
+  async function worker() {
+    for (; ; ) {
+      if (aborted) return;
+      const index = nextIndex++;
+      if (index >= urls.length) return;
+      const url = urls[index];
+      if (index > 0) await takeRateSlot();
+      if (aborted) return;
+      try {
+        const result = await withRetry(() => cb.inspectOne(url), {
+          maxRetries: INSPECT_MAX_RETRIES,
+          baseDelayMs: INSPECT_BASE_DELAY_MS,
+          maxDelayMs: INSPECT_MAX_BACKOFF_MS,
+          isRetryable: isRetryableGscInspectError,
+          sleep: sleep3,
+          onRetry: ({ attempt, delayMs, err }) => deps.log?.info("inspect.retry", {
+            url,
+            attempt,
+            delayMs: Math.round(delayMs),
+            error: err instanceof Error ? err.message : String(err)
+          })
+        });
+        cb.onResult(url, result, index);
+        inspected++;
+        consecutiveRetryableFailures = 0;
+      } catch (err) {
+        errors++;
+        cb.onError(url, err, index);
+        if (isRetryableGscInspectError(err)) {
+          consecutiveRetryableFailures++;
+          if (consecutiveRetryableFailures >= INSPECT_FAILFAST_THRESHOLD) {
+            deps.log?.error("inspect.circuit-break", {
+              consecutiveFailures: consecutiveRetryableFailures,
+              inspected,
+              errors,
+              remaining: urls.length - nextIndex
+            });
+            aborted = true;
+            abortError = err;
+            return;
+          }
         }
       }
     }
-    if (index < urls.length - 1) {
-      await sleep3(INSPECT_BASE_DELAY_MS + jitter() * INSPECT_PACING_JITTER_MS);
-    }
   }
-  return { inspected, errors, aborted: false };
+  await Promise.all(Array.from({ length: concurrency }, () => worker()));
+  return aborted ? { inspected, errors, aborted: true, abortError } : { inspected, errors, aborted: false };
 }
 
 // src/gsc-inspect-sitemap.ts
 var log6 = createLogger("InspectSitemap");
 async function executeInspectSitemap(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq6(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq7(runs.id, runId)).run();
   try {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getGoogleAuthConfig(opts.config);
     if (!googleClientId || !googleClientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq6(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq7(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -5711,8 +5776,21 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
     if (urls.length === 0) {
       throw new Error("No URLs found in sitemap");
     }
+    const skipped = Math.max(0, urls.length - INSPECT_SWEEP_MAX_URLS);
+    const targetUrls = skipped > 0 ? urls.slice(0, INSPECT_SWEEP_MAX_URLS) : urls;
+    if (skipped > 0) {
+      log6.warn("sitemap.over-budget", {
+        runId,
+        projectId,
+        sitemapUrls: urls.length,
+        inspecting: targetUrls.length,
+        skipped,
+        dailyQuota: INSPECT_DAILY_QUOTA,
+        note: `Sitemap has ${urls.length} pages; Google allows ${INSPECT_DAILY_QUOTA} URL inspections per property per day. Inspecting the first ${targetUrls.length}; ${skipped} pages will not have a verdict from this run.`
+      });
+    }
     const { inspected, errors, aborted, abortError } = await inspectUrlsPaced(
-      urls,
+      targetUrls,
       {
         inspectOne: (pageUrl) => inspectUrl(accessToken, pageUrl, propertyId),
         onResult: (pageUrl, result, index) => {
@@ -5722,7 +5800,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
           const rich = ir.richResultsResult;
           const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
           db.insert(gscUrlInspections).values({
-            id: crypto8.randomUUID(),
+            id: crypto9.randomUUID(),
             projectId,
             syncRunId: runId,
             url: pageUrl,
@@ -5758,52 +5836,24 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         `URL inspection aborted after ${INSPECT_FAILFAST_THRESHOLD} consecutive rate/access failures (likely GSC URL Inspection quota exhaustion or property access loss). Last error: ${detail}`
       );
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq6(gscUrlInspections.projectId, projectId)).all();
-    const latestByUrl = /* @__PURE__ */ new Map();
-    for (const row of allInspections) {
-      const existing = latestByUrl.get(row.url);
-      if (!existing || row.inspectedAt > existing.inspectedAt) {
-        latestByUrl.set(row.url, row);
-      }
-    }
-    let snapIndexed = 0;
-    let snapNotIndexed = 0;
-    const reasonCounts = {};
-    for (const [, row] of latestByUrl) {
-      if (row.indexingState === "INDEXING_ALLOWED") {
-        snapIndexed++;
-      } else {
-        snapNotIndexed++;
-        const reason = row.coverageState ?? "Unknown";
-        reasonCounts[reason] = (reasonCounts[reason] ?? 0) + 1;
-      }
-    }
-    const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and5(eq6(gscCoverageSnapshots.projectId, projectId), eq6(gscCoverageSnapshots.date, snapshotDate))).run();
-    db.insert(gscCoverageSnapshots).values({
-      id: crypto8.randomUUID(),
-      projectId,
-      syncRunId: runId,
-      date: snapshotDate,
-      indexed: snapIndexed,
-      notIndexed: snapNotIndexed,
-      reasonBreakdown: reasonCounts,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).run();
-    const status = errors > 0 && inspected > 0 ? "partial" : errors === urls.length ? "failed" : "completed";
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq6(runs.id, runId)).run();
+    const coverage = writeCoverageSnapshot(db, projectId, runId);
+    const snapIndexed = coverage.indexed;
+    const snapNotIndexed = coverage.notIndexed;
+    const attempted = targetUrls.length;
+    const status = skipped > 0 || errors > 0 && inspected > 0 ? "partial" : errors === attempted ? "failed" : "completed";
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq7(runs.id, runId)).run();
     log6.info("inspect.completed", { runId, projectId, inspected, errors, total: urls.length, indexed: snapIndexed, notIndexed: snapNotIndexed });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq6(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq7(runs.id, runId)).run();
     log6.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/bing-inspect-sitemap.ts
-import crypto9 from "crypto";
-import { eq as eq7, desc as desc2 } from "drizzle-orm";
+import crypto10 from "crypto";
+import { eq as eq8, desc as desc3 } from "drizzle-orm";
 var log7 = createLogger("BingInspectSitemap");
 function parseBingDate(value) {
   if (!value) return null;
@@ -5821,9 +5871,9 @@ function isBlockingIssueType(issueType) {
 }
 async function executeBingInspectSitemap(db, runId, projectId, opts) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq7(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq8(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq7(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq8(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -5841,7 +5891,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     if (sitemapUrls.length === 0) {
       throw new Error("No URLs found in sitemap");
     }
-    const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq7(bingUrlInspections.projectId, projectId)).all();
+    const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq8(bingUrlInspections.projectId, projectId)).all();
     const trackedUrls = new Set(trackedRows.map((r) => r.url));
     const discovered = sitemapUrls.filter((u) => !trackedUrls.has(u));
     log7.info("sitemap.diff", {
@@ -5890,7 +5940,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
           derivedInIndex = false;
         }
         db.insert(bingUrlInspections).values({
-          id: crypto9.randomUUID(),
+          id: crypto10.randomUUID(),
           projectId,
           url: pageUrl,
           httpCode,
@@ -5924,7 +5974,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
         await new Promise((r) => setTimeout(r, 1e3));
       }
     }
-    const allInspections = db.select().from(bingUrlInspections).where(eq7(bingUrlInspections.projectId, projectId)).orderBy(desc2(bingUrlInspections.inspectedAt)).all();
+    const allInspections = db.select().from(bingUrlInspections).where(eq8(bingUrlInspections.projectId, projectId)).orderBy(desc3(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -5948,7 +5998,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const snapNow = (/* @__PURE__ */ new Date()).toISOString();
     db.insert(bingCoverageSnapshots).values({
-      id: crypto9.randomUUID(),
+      id: crypto10.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -5967,7 +6017,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
       }
     }).run();
     const status = errors === sitemapUrls.length ? RunStatuses.failed : errors > 0 ? RunStatuses.partial : RunStatuses.completed;
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq7(runs.id, runId)).run();
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq8(runs.id, runId)).run();
     log7.info("inspect.completed", {
       runId,
       projectId,
@@ -5981,15 +6031,15 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq7(runs.id, runId)).run();
+    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq8(runs.id, runId)).run();
     log7.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/coverage-refresh.ts
-import crypto10 from "crypto";
-import { and as and6, desc as desc3, eq as eq8, inArray as inArray3 } from "drizzle-orm";
+import crypto11 from "crypto";
+import { and as and6, desc as desc4, eq as eq9, inArray as inArray3 } from "drizzle-orm";
 var log8 = createLogger("CoverageRefresh");
 var COVERAGE_REFRESH_MIN_INTERVAL_MS = 60 * 60 * 1e3;
 var ACTIVE_OR_DONE_STATUSES = [
@@ -6000,7 +6050,7 @@ var ACTIVE_OR_DONE_STATUSES = [
 ];
 var defaultDeps = { executeInspectSitemap };
 async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps, nowMs = Date.now()) {
-  const project = db.select({ canonicalDomain: projects.canonicalDomain }).from(projects).where(eq8(projects.id, projectId)).get();
+  const project = db.select({ canonicalDomain: projects.canonicalDomain }).from(projects).where(eq9(projects.id, projectId)).get();
   if (!project) return null;
   const { clientId, clientSecret } = getGoogleAuthConfig(config);
   if (!clientId || !clientSecret) return null;
@@ -6008,11 +6058,11 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
   if (!conn?.refreshToken || !conn.propertyId) return null;
   const recent = db.select({ createdAt: runs.createdAt }).from(runs).where(
     and6(
-      eq8(runs.projectId, projectId),
-      eq8(runs.kind, RunKinds["inspect-sitemap"]),
+      eq9(runs.projectId, projectId),
+      eq9(runs.kind, RunKinds["inspect-sitemap"]),
       inArray3(runs.status, ACTIVE_OR_DONE_STATUSES)
     )
-  ).orderBy(desc3(runs.createdAt)).limit(1).get();
+  ).orderBy(desc4(runs.createdAt)).limit(1).get();
   if (recent) {
     const ageMs = nowMs - Date.parse(recent.createdAt);
     if (Number.isFinite(ageMs) && ageMs < COVERAGE_REFRESH_MIN_INTERVAL_MS) {
@@ -6020,7 +6070,7 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
       return null;
     }
   }
-  const runId = crypto10.randomUUID();
+  const runId = crypto11.randomUUID();
   db.insert(runs).values({
     id: runId,
     projectId,
@@ -6043,9 +6093,9 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
 }
 
 // src/commoncrawl-sync.ts
-import crypto11 from "crypto";
+import crypto12 from "crypto";
 import path4 from "path";
-import { and as and7, eq as eq9, sql as sql4 } from "drizzle-orm";
+import { and as and7, eq as eq10, sql as sql4 } from "drizzle-orm";
 var log9 = createLogger("CommonCrawlSync");
 var INSERT_CHUNK_SIZE = 1e4;
 function defaultDeps2() {
@@ -6071,7 +6121,7 @@ async function executeReleaseSync(db, syncId, opts) {
       phaseDetail: "downloading vertices + edges",
       updatedAt: downloadStartedAt,
       error: null
-    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq10(ccReleaseSyncs.id, syncId)).run();
     const paths = ccReleasePaths(release);
     const releaseCacheDir = path4.join(deps.cacheDir, release);
     const vertexPath = path4.join(releaseCacheDir, paths.vertexFilename);
@@ -6094,7 +6144,7 @@ async function executeReleaseSync(db, syncId, opts) {
       vertexSha256: vertex.sha256,
       edgesSha256: edges.sha256,
       updatedAt: downloadFinishedAt
-    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq10(ccReleaseSyncs.id, syncId)).run();
     const allProjects = db.select().from(projects).all();
     const targets = Array.from(new Set(allProjects.map((p) => p.canonicalDomain)));
     let rows = [];
@@ -6110,15 +6160,15 @@ async function executeReleaseSync(db, syncId, opts) {
     }
     const queriedAt = deps.now().toISOString();
     db.transaction((tx) => {
-      tx.delete(backlinkDomains).where(eq9(backlinkDomains.releaseSyncId, syncId)).run();
-      tx.delete(backlinkSummaries).where(eq9(backlinkSummaries.releaseSyncId, syncId)).run();
+      tx.delete(backlinkDomains).where(eq10(backlinkDomains.releaseSyncId, syncId)).run();
+      tx.delete(backlinkSummaries).where(eq10(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: crypto11.randomUUID(),
+            id: crypto12.randomUUID(),
             projectId,
             releaseSyncId: syncId,
             release,
@@ -6138,7 +6188,7 @@ async function executeReleaseSync(db, syncId, opts) {
         const projectRows = rowsByProject.get(p.id) ?? [];
         const summary = computeSummary(projectRows);
         tx.insert(backlinkSummaries).values({
-          id: crypto11.randomUUID(),
+          id: crypto12.randomUUID(),
           projectId: p.id,
           releaseSyncId: syncId,
           source: BacklinkSources.commoncrawl,
@@ -6171,7 +6221,7 @@ async function executeReleaseSync(db, syncId, opts) {
       domainsDiscovered: rows.length,
       updatedAt: finishedAt,
       error: null
-    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq10(ccReleaseSyncs.id, syncId)).run();
     log9.info("sync.completed", {
       syncId,
       release,
@@ -6201,7 +6251,7 @@ async function executeReleaseSync(db, syncId, opts) {
       error: errorMsg,
       phaseDetail: null,
       updatedAt: finishedAt
-    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq10(ccReleaseSyncs.id, syncId)).run();
     log9.error("sync.failed", { syncId, release, error: errorMsg });
     throw err;
   }
@@ -6235,9 +6285,9 @@ function computeSummary(rows) {
 }
 
 // src/backlink-extract.ts
-import crypto12 from "crypto";
+import crypto13 from "crypto";
 import fs3 from "fs";
-import { and as and8, desc as desc4, eq as eq10 } from "drizzle-orm";
+import { and as and8, desc as desc5, eq as eq11 } from "drizzle-orm";
 var log10 = createLogger("BacklinkExtract");
 function defaultDeps3() {
   return {
@@ -6249,13 +6299,13 @@ function defaultDeps3() {
 async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
   const deps = { ...defaultDeps3(), ...opts.deps };
   const startedAt = deps.now().toISOString();
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq10(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq11(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq10(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq11(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
-    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq10(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq10(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc4(ccReleaseSyncs.createdAt)).limit(1).get();
+    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq11(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq11(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc5(ccReleaseSyncs.createdAt)).limit(1).get();
     if (!sync) {
       throw new Error("No ready release sync available \u2014 run `canonry backlinks sync` first");
     }
@@ -6284,14 +6334,14 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     db.transaction((tx) => {
       tx.delete(backlinkDomains).where(
         and8(
-          eq10(backlinkDomains.projectId, projectId),
-          eq10(backlinkDomains.source, BacklinkSources.commoncrawl),
-          eq10(backlinkDomains.release, release)
+          eq11(backlinkDomains.projectId, projectId),
+          eq11(backlinkDomains.source, BacklinkSources.commoncrawl),
+          eq11(backlinkDomains.release, release)
         )
       ).run();
       if (rows.length > 0) {
         const values = rows.map((r) => ({
-          id: crypto12.randomUUID(),
+          id: crypto13.randomUUID(),
           projectId,
           releaseSyncId: syncId,
           source: BacklinkSources.commoncrawl,
@@ -6305,7 +6355,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }
       const summary = computeSummary2(rows);
       tx.insert(backlinkSummaries).values({
-        id: crypto12.randomUUID(),
+        id: crypto13.randomUUID(),
         projectId,
         releaseSyncId: syncId,
         source: BacklinkSources.commoncrawl,
@@ -6329,7 +6379,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }).run();
     });
     const finishedAt = deps.now().toISOString();
-    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq10(runs.id, runId)).run();
+    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq11(runs.id, runId)).run();
     log10.info("extract.completed", { runId, projectId, release, rows: rows.length });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -6338,7 +6388,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       status: RunStatuses.failed,
       error: errorMsg,
       finishedAt
-    }).where(eq10(runs.id, runId)).run();
+    }).where(eq11(runs.id, runId)).run();
     log10.error("extract.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -6348,8 +6398,8 @@ function computeSummary2(rows) {
 }
 
 // src/discovery-run.ts
-import crypto13 from "crypto";
-import { and as and9, eq as eq11 } from "drizzle-orm";
+import crypto14 from "crypto";
+import { and as and9, eq as eq12 } from "drizzle-orm";
 var log11 = createLogger("DiscoveryRun");
 var DEFAULT_SEED_COUNT = 30;
 var EMBED_RETRY_MAX_RETRIES = 3;
@@ -6391,11 +6441,11 @@ async function embedWithRetry(fn, opts = {}) {
 var QUERIES_PER_INTENT_BUCKET = 6;
 async function executeDiscoveryRun(opts) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  opts.db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq11(runs.id, opts.runId)).run();
+  opts.db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq12(runs.id, opts.runId)).run();
   try {
-    const projectRow = opts.db.select().from(projects).where(eq11(projects.id, opts.projectId)).get();
+    const projectRow = opts.db.select().from(projects).where(eq12(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(eq11(competitors.projectId, opts.projectId)).all().map((r) => r.domain.toLowerCase());
+    const projectCompetitors = opts.db.select({ domain: competitors.domain }).from(competitors).where(eq12(competitors.projectId, opts.projectId)).all().map((r) => r.domain.toLowerCase());
     const canonicalDomains = effectiveDomains({
       canonicalDomain: projectRow.canonicalDomain,
       ownedDomains: projectRow.ownedDomains
@@ -6433,7 +6483,7 @@ async function executeDiscoveryRun(opts) {
       seedProvider: result.seedProvider,
       result
     });
-    opts.db.update(runs).set({ status: RunStatuses.completed, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq11(runs.id, opts.runId)).run();
+    opts.db.update(runs).set({ status: RunStatuses.completed, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq12(runs.id, opts.runId)).run();
     log11.info("discovery.completed", {
       runId: opts.runId,
       sessionId: opts.sessionId,
@@ -6448,7 +6498,7 @@ async function executeDiscoveryRun(opts) {
       status: RunStatuses.failed,
       finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
       error: errorMsg
-    }).where(eq11(runs.id, opts.runId)).run();
+    }).where(eq12(runs.id, opts.runId)).run();
   }
 }
 function buildDefaultDeps(registry) {
@@ -6698,12 +6748,12 @@ function writeDiscoveryInsight(db, input) {
   });
   db.transaction((tx) => {
     tx.update(insights).set({ dismissed: true }).where(and9(
-      eq11(insights.projectId, input.projectId),
-      eq11(insights.type, "discovery.basket-divergence"),
-      eq11(insights.dismissed, false)
+      eq12(insights.projectId, input.projectId),
+      eq12(insights.type, "discovery.basket-divergence"),
+      eq12(insights.dismissed, false)
     )).run();
     tx.insert(insights).values({
-      id: crypto13.randomUUID(),
+      id: crypto14.randomUUID(),
       projectId: input.projectId,
       runId: input.runId,
       type: "discovery.basket-divergence",
@@ -6739,8 +6789,8 @@ function buildDiscoveryInsightTitle(input) {
 }
 
 // src/execute-site-audit.ts
-import crypto14 from "crypto";
-import { eq as eq12 } from "drizzle-orm";
+import crypto15 from "crypto";
+import { eq as eq13 } from "drizzle-orm";
 import { runSitemapAudit } from "@ainyc/aeo-audit";
 var log12 = createLogger("SiteAudit");
 var SITE_AUDIT_DEFAULT_PAGE_LIMIT = 500;
@@ -6803,9 +6853,9 @@ function computeFactorAverages(pages) {
 }
 async function executeSiteAudit(db, runId, projectId, opts = {}) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt }).where(eq12(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt }).where(eq13(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq12(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq13(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -6838,7 +6888,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     db.transaction((tx) => {
       tx.insert(siteAuditSnapshots).values({
-        id: crypto14.randomUUID(),
+        id: crypto15.randomUUID(),
         projectId,
         runId,
         sitemapUrl: report.sitemapUrl,
@@ -6867,7 +6917,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       }).run();
       for (const page of report.pages) {
         tx.insert(siteAuditPages).values({
-          id: crypto14.randomUUID(),
+          id: crypto15.randomUUID(),
           projectId,
           runId,
           url: page.url,
@@ -6878,7 +6928,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           createdAt: finishedAt
         }).run();
       }
-      tx.update(runs).set({ status, finishedAt }).where(eq12(runs.id, runId)).run();
+      tx.update(runs).set({ status, finishedAt }).where(eq13(runs.id, runId)).run();
     });
     log12.info("completed", {
       runId,
@@ -6890,14 +6940,14 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq12(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq13(runs.id, runId)).run();
     log12.error("failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/commands/backfill.ts
-import { and as and10, eq as eq13, inArray as inArray4, isNull, sql as sql5 } from "drizzle-orm";
+import { and as and10, eq as eq14, inArray as inArray4, isNull, sql as sql5 } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
@@ -6905,7 +6955,7 @@ async function backfillAnswerVisibilityCommand(opts) {
   migrate(db);
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq13(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -6914,9 +6964,9 @@ async function backfillAnswerVisibilityCommand(opts) {
   let providerErrors = 0;
   if (scopedProjects.length > 0) {
     const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and10(
-      eq13(runs.kind, RunKinds["answer-visibility"]),
+      eq14(runs.kind, RunKinds["answer-visibility"]),
       inArray4(runs.projectId, scopedProjects.map((project) => project.id))
-    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq13(runs.kind, RunKinds["answer-visibility"])).all();
+    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq14(runs.kind, RunKinds["answer-visibility"])).all();
     const runIdsByProject = /* @__PURE__ */ new Map();
     for (const run of runRows) {
       const existing = runIdsByProject.get(run.projectId);
@@ -6924,7 +6974,7 @@ async function backfillAnswerVisibilityCommand(opts) {
       else runIdsByProject.set(run.projectId, [run.id]);
     }
     for (const project of scopedProjects) {
-      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq13(competitors.projectId, project.id)).all().map((row) => row.domain);
+      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq14(competitors.projectId, project.id)).all().map((row) => row.domain);
       const runIds = runIdsByProject.get(project.id) ?? [];
       if (runIds.length === 0) continue;
       const projectDomains = effectiveDomains({
@@ -7017,7 +7067,7 @@ async function backfillAnswerVisibilityCommand(opts) {
           } else {
             db.transaction((tx) => {
               for (const update of pendingUpdates) {
-                tx.update(querySnapshots).set(update.patch).where(eq13(querySnapshots.id, update.id)).run();
+                tx.update(querySnapshots).set(update.patch).where(eq14(querySnapshots.id, update.id)).run();
               }
             });
             updated += pendingUpdates.length;
@@ -7066,7 +7116,7 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 function backfillNormalizedPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq13(gaTrafficSnapshots.projectId, opts.projectId));
+    baseConditions.push(eq14(gaTrafficSnapshots.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaTrafficSnapshots.id,
@@ -7087,7 +7137,7 @@ function backfillNormalizedPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq13(gaTrafficSnapshots.id, row.id)).run();
+        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq14(gaTrafficSnapshots.id, row.id)).run();
         updated++;
       }
     });
@@ -7101,7 +7151,7 @@ async function backfillNormalizedPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq13(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq14(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -7138,7 +7188,7 @@ async function backfillNormalizedPathsCommand(opts) {
 function backfillAiReferralPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq13(gaAiReferrals.projectId, opts.projectId));
+    baseConditions.push(eq14(gaAiReferrals.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaAiReferrals.id,
@@ -7159,7 +7209,7 @@ function backfillAiReferralPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq13(gaAiReferrals.id, row.id)).run();
+        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq14(gaAiReferrals.id, row.id)).run();
         updated++;
       }
     });
@@ -7173,7 +7223,7 @@ async function backfillAiReferralPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq13(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq14(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -7209,10 +7259,10 @@ async function backfillAiReferralPathsCommand(opts) {
 }
 function backfillProjectAnswerMentions(db, projectId, opts) {
   const isDryRun = opts?.dryRun === true;
-  const project = db.select().from(projects).where(eq13(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq14(projects.id, projectId)).get();
   if (!project) return { examined: 0, updated: 0, mentioned: 0 };
-  const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq13(competitors.projectId, projectId)).all().map((row) => row.domain);
-  const runRows = db.select({ id: runs.id }).from(runs).where(and10(eq13(runs.kind, RunKinds["answer-visibility"]), eq13(runs.projectId, projectId))).all();
+  const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq14(competitors.projectId, projectId)).all().map((row) => row.domain);
+  const runRows = db.select({ id: runs.id }).from(runs).where(and10(eq14(runs.kind, RunKinds["answer-visibility"]), eq14(runs.projectId, projectId))).all();
   const runIds = runRows.map((r) => r.id);
   let examined = 0;
   let updated = 0;
@@ -7286,7 +7336,7 @@ function backfillProjectAnswerMentions(db, projectId, opts) {
       } else {
         db.transaction((tx) => {
           for (const update of pendingUpdates) {
-            tx.update(querySnapshots).set(update.patch).where(eq13(querySnapshots.id, update.id)).run();
+            tx.update(querySnapshots).set(update.patch).where(eq14(querySnapshots.id, update.id)).run();
           }
         });
         updated += pendingUpdates.length;
@@ -7301,7 +7351,7 @@ async function backfillAnswerMentionsCommand(opts) {
   migrate(db);
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq13(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -7520,7 +7570,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
-  const project = db.select().from(projects).where(eq13(projects.name, opts.project)).get();
+  const project = db.select().from(projects).where(eq14(projects.name, opts.project)).get();
   if (!project) {
     throw new Error(`Project "${opts.project}" not found`);
   }
@@ -7532,7 +7582,7 @@ async function backfillSnapshotAttributionCommand(opts) {
 `);
   }
   const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and10(
-    eq13(auditLog.projectId, project.id),
+    eq14(auditLog.projectId, project.id),
     inArray4(auditLog.action, ["keywords.appended", "keywords.deleted", "queries.appended", "queries.deleted", "queries.replaced"])
   )).orderBy(auditLog.createdAt).all();
   const history = replayQueryAuditLog(events);
@@ -7540,8 +7590,8 @@ async function backfillSnapshotAttributionCommand(opts) {
     runId: runs.id,
     createdAt: runs.createdAt,
     location: runs.location
-  }).from(runs).innerJoin(querySnapshots, eq13(querySnapshots.runId, runs.id)).where(and10(
-    eq13(runs.projectId, project.id),
+  }).from(runs).innerJoin(querySnapshots, eq14(querySnapshots.runId, runs.id)).where(and10(
+    eq14(runs.projectId, project.id),
     isNull(querySnapshots.queryId),
     isNull(querySnapshots.queryText)
   )).groupBy(runs.id).orderBy(runs.createdAt).all();
@@ -7564,7 +7614,7 @@ async function backfillSnapshotAttributionCommand(opts) {
       createdAt: querySnapshots.createdAt,
       answerText: querySnapshots.answerText
     }).from(querySnapshots).where(and10(
-      eq13(querySnapshots.runId, run.runId),
+      eq14(querySnapshots.runId, run.runId),
       isNull(querySnapshots.queryId),
       isNull(querySnapshots.queryText)
     )).orderBy(querySnapshots.provider, querySnapshots.createdAt).all();
@@ -7630,7 +7680,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   if (!isDryRun && updates.length > 0) {
     db.transaction((tx) => {
       for (const u of updates) {
-        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq13(querySnapshots.id, u.id)).run();
+        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq14(querySnapshots.id, u.id)).run();
       }
     });
   }
@@ -7704,7 +7754,7 @@ async function backfillTrafficClassificationCommand(opts) {
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
   const isJson = isMachineFormat(opts?.format);
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq13(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
   if (scopedProjects.length === 0) {
     if (projectFilter && !isJson) {
       process.stderr.write(`No project named "${projectFilter}".
@@ -7730,7 +7780,7 @@ async function backfillTrafficClassificationCommand(opts) {
     byBot: {}
   };
   const unknownCountRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and10(
-    eq13(rawEventSamples.eventType, "unknown"),
+    eq14(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).get();
   result.unknownBefore = Number(unknownCountRow?.n ?? 0);
@@ -7743,7 +7793,7 @@ async function backfillTrafficClassificationCommand(opts) {
     pathNormalized: rawEventSamples.pathNormalized,
     status: rawEventSamples.status
   }).from(rawEventSamples).where(and10(
-    eq13(rawEventSamples.eventType, "unknown"),
+    eq14(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).all();
   result.examined = unknownSamples.length;
@@ -7782,7 +7832,7 @@ async function backfillTrafficClassificationCommand(opts) {
     result.reclassified++;
     result.byBot[classified.botId] = (result.byBot[classified.botId] ?? 0) + 1;
     if (isDryRun) continue;
-    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq13(rawEventSamples.id, snap.id)).run();
+    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq14(rawEventSamples.id, snap.id)).run();
     const tsHour = new Date(snap.ts);
     tsHour.setUTCMinutes(0, 0, 0);
     if (userFetch) {
@@ -7847,7 +7897,7 @@ async function backfillTrafficClassificationCommand(opts) {
   }
   if (!isDryRun) {
     const afterRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and10(
-      eq13(rawEventSamples.eventType, "unknown"),
+      eq14(rawEventSamples.eventType, "unknown"),
       inArray4(rawEventSamples.projectId, projectIds)
     )).get();
     result.unknownAfter = Number(afterRow?.n ?? 0);
@@ -7882,7 +7932,7 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 }
 
 // src/commands/skills.ts
-import crypto15 from "crypto";
+import crypto16 from "crypto";
 import fs4 from "fs";
 import os4 from "os";
 import path5 from "path";
@@ -7937,7 +7987,7 @@ function walkRelative(dir, prefix = "") {
   return out.sort();
 }
 function sha256File(filePath) {
-  return crypto15.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
+  return crypto16.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
 }
 function readSkillManifest(skillDir) {
   try {
@@ -8279,9 +8329,9 @@ var ProviderRegistry = class {
 };
 
 // src/scheduler.ts
-import crypto16 from "crypto";
+import crypto17 from "crypto";
 import cron from "node-cron";
-import { and as and11, eq as eq14, inArray as inArray5, notExists, sql as sql6 } from "drizzle-orm";
+import { and as and11, eq as eq15, inArray as inArray5, notExists, sql as sql6 } from "drizzle-orm";
 var log13 = createLogger("Scheduler");
 var DEFAULT_HEALTH_CRON = "0 */6 * * *";
 function taskKey(projectId, kind) {
@@ -8314,15 +8364,15 @@ var Scheduler = class {
   ensureHealthSchedules() {
     const projectsWithoutHealth = this.db.select({ id: projects.id }).from(projects).where(notExists(
       this.db.select({ one: sql6`1` }).from(schedules).where(and11(
-        eq14(schedules.projectId, projects.id),
-        eq14(schedules.kind, SchedulableRunKinds.doctor)
+        eq15(schedules.projectId, projects.id),
+        eq15(schedules.kind, SchedulableRunKinds.doctor)
       ))
     )).all();
     if (projectsWithoutHealth.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const project of projectsWithoutHealth) {
       this.db.insert(schedules).values({
-        id: crypto16.randomUUID(),
+        id: crypto17.randomUUID(),
         projectId: project.id,
         kind: SchedulableRunKinds.doctor,
         cronExpr: DEFAULT_HEALTH_CRON,
@@ -8366,7 +8416,7 @@ var Scheduler = class {
   start() {
     this.ensureHealthSchedules();
     this.ensureQueryBaskets();
-    const allSchedules = this.db.select().from(schedules).where(eq14(schedules.enabled, true)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq15(schedules.enabled, true)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
@@ -8396,7 +8446,7 @@ var Scheduler = class {
       this.stopTask(key, existing, "Stopped");
       this.tasks.delete(key);
     }
-    const schedule = this.db.select().from(schedules).where(and11(eq14(schedules.projectId, projectId), eq14(schedules.kind, kind))).get();
+    const schedule = this.db.select().from(schedules).where(and11(eq15(schedules.projectId, projectId), eq15(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -8437,21 +8487,21 @@ var Scheduler = class {
     this.db.update(schedules).set({
       nextRunAt: nextRunFromCron(cronExpr, timezone),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq14(schedules.id, scheduleId)).run();
+    }).where(eq15(schedules.id, scheduleId)).run();
     const label = schedule.preset ?? cronExpr;
     log13.info("cron.registered", { projectId, kind, schedule: label, timezone });
   }
   triggerRun(scheduleId, projectId, kind) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const currentSchedule = this.db.select().from(schedules).where(eq14(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq15(schedules.id, scheduleId)).get();
       if (!currentSchedule || !currentSchedule.enabled) {
         log13.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId, kind);
         return;
       }
       const nextRunAt = nextRunFromCron(currentSchedule.cronExpr, currentSchedule.timezone);
-      const project = this.db.select().from(projects).where(eq14(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
       if (!project) {
         log13.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
         this.remove(projectId, kind);
@@ -8471,7 +8521,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log13.info("traffic-sync.triggered", { projectName: project.name, sourceId });
         this.callbacks.onTrafficSyncRequested(project.name, sourceId);
         return;
@@ -8481,7 +8531,7 @@ var Scheduler = class {
           log13.warn("gbp-sync.no-callback", { scheduleId, projectId, msg: "host did not register onGbpSyncRequested" });
           return;
         }
-        const runId2 = crypto16.randomUUID();
+        const runId2 = crypto17.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -8494,7 +8544,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log13.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onGbpSyncRequested(runId2, projectId);
         return;
@@ -8505,16 +8555,16 @@ var Scheduler = class {
           return;
         }
         const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and11(
-          eq14(runs.projectId, projectId),
-          eq14(runs.kind, RunKinds["ads-sync"]),
+          eq15(runs.projectId, projectId),
+          eq15(runs.kind, RunKinds["ads-sync"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (activeAdsRun) {
           log13.info("ads-sync.skipped-active", { projectName: project.name, activeRunId: activeAdsRun.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq14(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq15(schedules.id, currentSchedule.id)).run();
           return;
         }
-        const runId2 = crypto16.randomUUID();
+        const runId2 = crypto17.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -8527,7 +8577,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log13.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onAdsSyncRequested(runId2, projectId);
         return;
@@ -8541,7 +8591,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log13.info("data-refresh.triggered", { projectName: project.name });
         this.callbacks.onDataRefreshRequested(project.name);
         return;
@@ -8555,7 +8605,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log13.info("doctor.triggered", { projectName: project.name });
         this.callbacks.onDoctorRequested(project.name);
         return;
@@ -8569,7 +8619,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log13.info("backlinks-sync.triggered", { projectName: project.name });
         this.callbacks.onBacklinksSyncRequested(project.name);
         return;
@@ -8580,16 +8630,16 @@ var Scheduler = class {
           return;
         }
         const active = this.db.select({ id: runs.id }).from(runs).where(and11(
-          eq14(runs.projectId, projectId),
-          eq14(runs.kind, RunKinds["site-audit"]),
+          eq15(runs.projectId, projectId),
+          eq15(runs.kind, RunKinds["site-audit"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (active) {
           log13.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq14(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq15(schedules.id, currentSchedule.id)).run();
           return;
         }
-        const runId2 = crypto16.randomUUID();
+        const runId2 = crypto17.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -8602,7 +8652,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log13.info("site-audit.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onSiteAuditRequested(runId2, projectId);
         return;
@@ -8635,7 +8685,7 @@ var Scheduler = class {
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         return;
       }
       const runId = queueResult.runId;
@@ -8643,7 +8693,7 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq14(schedules.id, currentSchedule.id)).run();
+      }).where(eq15(schedules.id, currentSchedule.id)).run();
       log13.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
       this.callbacks.onRunCreated(runId, projectId, providers, resolvedLocation);
     } catch (err) {
@@ -8676,8 +8726,8 @@ async function refreshAllIntegrations(client, projectName) {
 }
 
 // src/notifier.ts
-import { eq as eq15, desc as desc5, and as and12, inArray as inArray6, or } from "drizzle-orm";
-import crypto17 from "crypto";
+import { eq as eq16, desc as desc6, and as and12, inArray as inArray6, or } from "drizzle-orm";
+import crypto18 from "crypto";
 var log15 = createLogger("Notifier");
 var Notifier = class {
   db;
@@ -8689,18 +8739,18 @@ var Notifier = class {
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
     log15.info("run.completed", { runId, projectId });
-    const notifs = this.db.select().from(notifications).where(eq15(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) {
       log15.info("notifications.none-enabled", { projectId });
       return;
     }
     log15.info("notifications.found", { projectId, count: notifs.length });
-    const run = this.db.select().from(runs).where(eq15(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
     if (!run) {
       log15.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
-    const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
@@ -8753,7 +8803,7 @@ var Notifier = class {
    * inferred from the absence of a webhook.
    */
   async onHealthChecked(projectId, report) {
-    const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping health notification" });
       return null;
@@ -8784,7 +8834,7 @@ var Notifier = class {
     const status = noSignal ? "warn" : worst ? worst.status : "ok";
     const code = noSignal ? "health.no-signal" : worst?.code ?? "health.ok";
     const summary = noSignal ? `No health check produced a result (${report.checks.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(eq15(doctorHealthState.projectId, projectId)).get();
+    const previous = this.db.select().from(doctorHealthState).where(eq16(doctorHealthState.projectId, projectId)).get();
     const previousStatus = previous?.status ?? null;
     let event = null;
     if (previous === void 0) {
@@ -8799,13 +8849,13 @@ var Notifier = class {
     if (previous === void 0) {
       this.db.insert(doctorHealthState).values({ ...observation, notifiedAt: null }).run();
     } else {
-      this.db.update(doctorHealthState).set(observation).where(eq15(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set(observation).where(eq16(doctorHealthState.projectId, projectId)).run();
     }
     if (!event) {
       log15.info("health.unchanged", { projectId, status, code });
       return null;
     }
-    const notifs = this.db.select().from(notifications).where(eq15(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     const payload = {
       source: "canonry",
       event,
@@ -8829,7 +8879,7 @@ var Notifier = class {
       delivered += 1;
     }
     if (delivered > 0) {
-      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq15(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq16(doctorHealthState.projectId, projectId)).run();
     }
     log15.info("health.notified", { projectId, event, status, code, subscribers: notifs.length, delivered });
     return event;
@@ -8842,11 +8892,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(eq15(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq15(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = notif.config;
@@ -8876,7 +8926,7 @@ var Notifier = class {
     }
   }
   computeTransitions(runId, projectId) {
-    const thisRun = this.db.select().from(runs).where(eq15(runs.id, runId)).get();
+    const thisRun = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
     if (!thisRun) return [];
     const completeness = measurementRunCompleteness(this.db, runId);
     if (completeness.planned && !completeness.complete) {
@@ -8888,9 +8938,9 @@ var Notifier = class {
       return [];
     }
     const groupSiblings = this.db.select().from(runs).where(and12(
-      eq15(runs.projectId, projectId),
-      eq15(runs.kind, thisRun.kind),
-      eq15(runs.createdAt, thisRun.createdAt)
+      eq16(runs.projectId, projectId),
+      eq16(runs.kind, thisRun.kind),
+      eq16(runs.createdAt, thisRun.createdAt)
     )).all();
     const stillPending = groupSiblings.some((r) => r.status === "queued" || r.status === "running");
     if (stillPending) return [];
@@ -8906,7 +8956,7 @@ 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(eq15(projects.id, projectId)).get();
+    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq16(projects.id, projectId)).get();
     const locationCount = Math.max(
       1,
       (projectLocations?.locations ?? []).length
@@ -8914,11 +8964,11 @@ var Notifier = class {
     const RECENT_FETCH_LIMIT = Math.max(8, locationCount * 4);
     const recentRuns = this.db.select().from(runs).where(
       and12(
-        eq15(runs.projectId, projectId),
-        eq15(runs.kind, thisRun.kind),
-        or(eq15(runs.status, "completed"), eq15(runs.status, "partial"))
+        eq16(runs.projectId, projectId),
+        eq16(runs.kind, thisRun.kind),
+        or(eq16(runs.status, "completed"), eq16(runs.status, "partial"))
       )
-    ).orderBy(desc5(runs.createdAt), desc5(runs.id)).limit(RECENT_FETCH_LIMIT).all();
+    ).orderBy(desc6(runs.createdAt), desc6(runs.id)).limit(RECENT_FETCH_LIMIT).all();
     const groups = groupRunsByCreatedAt(recentRuns);
     const currentGroupIdx = groups.findIndex((g) => g[0]?.createdAt === thisRun.createdAt);
     if (currentGroupIdx < 0) return [];
@@ -8933,7 +8983,7 @@ var Notifier = class {
       provider: querySnapshots.provider,
       location: querySnapshots.location,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(queries, eq15(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
+    }).from(querySnapshots).leftJoin(queries, eq16(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
     const previousSnapshots = this.db.select({
       queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
@@ -9003,7 +9053,7 @@ var Notifier = class {
   }
   logDelivery(projectId, notificationId, event, status, error) {
     this.db.insert(auditLog).values({
-      id: crypto17.randomUUID(),
+      id: crypto18.randomUUID(),
       projectId,
       actor: "scheduler",
       action: `notification.${status}`,
@@ -9016,7 +9066,7 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-import { eq as eq16 } from "drizzle-orm";
+import { eq as eq17 } from "drizzle-orm";
 var log16 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(db, notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
@@ -9032,7 +9082,7 @@ var RunCoordinator = class {
   onInsightsGenerated;
   onAeroEvent;
   async onRunCompleted(runId, projectId) {
-    const runRow = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
+    const runRow = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
     const kind = runRow?.kind ?? RunKinds["answer-visibility"];
     if (runRow?.trigger === RunTriggers.probe) {
       log16.info("probe.skip-side-effects", { runId, projectId, kind });
@@ -9123,7 +9173,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(eq16(discoverySessions.runId, runId)).get();
+    const session = this.db.select().from(discoverySessions).where(eq17(discoverySessions.runId, runId)).get();
     const competitorMap = session ? session.competitorMap : [];
     return {
       kind: RunKinds["aeo-discover-probe"],
@@ -9165,8 +9215,8 @@ function analysisResultFromInsights(insights2) {
 }
 
 // src/agent/session-registry.ts
-import crypto21 from "crypto";
-import { eq as eq18 } from "drizzle-orm";
+import crypto22 from "crypto";
+import { eq as eq19 } from "drizzle-orm";
 
 // src/agent/session.ts
 import fs7 from "fs";
@@ -9909,7 +9959,7 @@ function buildAeroStateTools(ctx, opts = {}) {
 }
 
 // src/agent/llm-usage.ts
-import crypto18 from "crypto";
+import crypto19 from "crypto";
 var AeroLlmUsageFeatures = {
   turn: "aero.turn"
 };
@@ -9928,7 +9978,7 @@ function recordLlmUsageEvent(args) {
     const usage = args.message.usage;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     args.db.insert(llmUsageEvents).values({
-      id: crypto18.randomUUID(),
+      id: crypto19.randomUUID(),
       projectId: args.projectId,
       runId: args.runId,
       agentSessionId: args.agentSessionId,
@@ -10004,7 +10054,7 @@ function splitAeroAnthropicSystemCachePayload(payload, model) {
 }
 
 // src/agent/tool-usage.ts
-import crypto19 from "crypto";
+import crypto20 from "crypto";
 var AeroToolEventStatuses = {
   success: "success",
   error: "error"
@@ -10067,7 +10117,7 @@ function createAeroToolUsageHooks(args) {
 function recordAgentToolEvent(args) {
   try {
     args.db.insert(agentToolEvents).values({
-      id: crypto19.randomUUID(),
+      id: crypto20.randomUUID(),
       projectId: args.projectId,
       agentSessionId: args.agentSessionId,
       toolCallId: args.toolCallId,
@@ -10294,8 +10344,8 @@ async function loadExternalMcpTools(servers, opts = {}) {
 }
 
 // src/agent/memory-store.ts
-import crypto20 from "crypto";
-import { and as and13, desc as desc6, eq as eq17, like, sql as sql7 } from "drizzle-orm";
+import crypto21 from "crypto";
+import { and as and13, desc as desc7, eq as eq18, like, sql as sql7 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -10309,7 +10359,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq17(agentMemory.projectId, projectId)).orderBy(desc6(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq18(agentMemory.projectId, projectId)).orderBy(desc7(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -10323,7 +10373,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 = crypto20.randomUUID();
+  const id = crypto21.randomUUID();
   db.insert(agentMemory).values({
     id,
     projectId: args.projectId,
@@ -10340,12 +10390,12 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and13(eq17(agentMemory.projectId, args.projectId), eq17(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and13(eq18(agentMemory.projectId, args.projectId), eq18(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(and13(eq17(agentMemory.projectId, projectId), eq17(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and13(eq18(agentMemory.projectId, projectId), eq18(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -10360,7 +10410,7 @@ function writeCompactionNote(db, args) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const key = `${COMPACTION_KEY_PREFIX}${args.sessionId}:${now}`;
-  const id = crypto20.randomUUID();
+  const id = crypto21.randomUUID();
   let inserted;
   db.transaction((tx) => {
     tx.insert(agentMemory).values({
@@ -10375,15 +10425,15 @@ function writeCompactionNote(db, args) {
     const sessionPrefix = `${COMPACTION_KEY_PREFIX}${args.sessionId}:`;
     const existing = tx.select({ id: agentMemory.id, updatedAt: agentMemory.updatedAt }).from(agentMemory).where(
       and13(
-        eq17(agentMemory.projectId, args.projectId),
+        eq18(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
-    ).orderBy(desc6(agentMemory.updatedAt)).all();
+    ).orderBy(desc7(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
       tx.delete(agentMemory).where(sql7`${agentMemory.id} IN (${sql7.join(stale.map((s) => sql7`${s}`), sql7`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and13(eq17(agentMemory.projectId, args.projectId), eq17(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and13(eq18(agentMemory.projectId, args.projectId), eq18(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -10610,7 +10660,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq18(agentSessions.projectId, projectId)).run();
+        }).where(eq19(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -10639,7 +10689,7 @@ var SessionRegistry = class {
     }
     const { provider, modelId } = resolveSessionProviderAndModel(this.opts.config, preferences);
     const systemPrompt = loadAeroSystemPrompt();
-    const sessionId = crypto21.randomUUID();
+    const sessionId = crypto22.randomUUID();
     const agent = createAeroSession({
       projectName,
       client: this.opts.client,
@@ -10844,7 +10894,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq18(agentSessions.projectId, projectId)).run();
+    }).where(eq19(agentSessions.projectId, projectId)).run();
   }
   /** Persist a session's transcript back to the DB. Call after any run settles. */
   save(projectName) {
@@ -11008,17 +11058,17 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq18(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq19(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq18(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq19(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.opts.db.insert(agentSessions).values({
-      id: params.id ?? crypto21.randomUUID(),
+      id: params.id ?? crypto22.randomUUID(),
       projectId: params.projectId,
       systemPrompt: params.systemPrompt,
       modelProvider: params.provider ?? params.modelProvider ?? AgentProviderIds.claude,
@@ -11031,14 +11081,14 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq18(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq19(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/agent-routes.ts
-import { eq as eq19 } from "drizzle-orm";
+import { eq as eq20 } from "drizzle-orm";
 function resolveProject(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq19(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq20(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -11047,7 +11097,7 @@ function registerAgentRoutes(app, opts) {
     "/projects/:name/agent/transcript",
     async (request) => {
       const project = resolveProject(opts.db, request.params.name);
-      const row = opts.db.select().from(agentSessions).where(eq19(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq20(agentSessions.projectId, project.id)).get();
       if (!row) {
         return { messages: [], modelProvider: null, modelId: null, updatedAt: null };
       }
@@ -11071,7 +11121,7 @@ function registerAgentRoutes(app, opts) {
     async (request) => {
       const project = resolveProject(opts.db, request.params.name);
       opts.sessionRegistry.reset(project.name);
-      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq19(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -12014,20 +12064,20 @@ function clipText(value, length) {
 }
 
 // src/research-runner.ts
-import { and as and14, eq as eq20, inArray as inArray7, sql as sql8 } from "drizzle-orm";
+import { and as and14, eq as eq21, inArray as inArray7, sql as sql8 } from "drizzle-orm";
 var unfinishedResearchQueryStatuses = [ResearchQueryStatuses.queued, ResearchQueryStatuses.running];
 function finalResearchRunStatus(completed, failed) {
   if (failed === 0) return ResearchRunStatuses.completed;
   return completed > 0 ? ResearchRunStatuses.partial : ResearchRunStatuses.failed;
 }
 async function executeResearchRun(db, registry, runId, projectId) {
-  const run = db.select().from(researchRuns).where(and14(eq20(researchRuns.id, runId), eq20(researchRuns.projectId, projectId))).get();
+  const run = db.select().from(researchRuns).where(and14(eq21(researchRuns.id, runId), eq21(researchRuns.projectId, projectId))).get();
   if (!run || run.status !== ResearchRunStatuses.queued) return;
-  const project = db.select().from(projects).where(eq20(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq21(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(and14(eq20(researchRuns.id, runId), eq20(researchRuns.status, ResearchRunStatuses.queued))).run();
+  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and14(eq21(researchRuns.id, runId), eq21(researchRuns.status, ResearchRunStatuses.queued))).run();
   if (claim.changes !== 1) return;
   let reserved = 0;
   let dispatched = 0;
@@ -12051,8 +12101,8 @@ async function executeResearchRun(db, registry, runId, projectId) {
     }
     reserved = run.totalQueries;
     reservation = { scope, period };
-    const rows = db.select().from(researchRunQueries).where(eq20(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
-    const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq20(competitors.projectId, projectId)).all().map((row) => row.domain);
+    const rows = db.select().from(researchRunQueries).where(eq21(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
+    const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq21(competitors.projectId, projectId)).all().map((row) => row.domain);
     const domains = effectiveDomains(project);
     const brands = effectiveBrandNames(project);
     const config = { ...provider.config, model: run.resolvedModel };
@@ -12060,7 +12110,7 @@ async function executeResearchRun(db, registry, runId, projectId) {
     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(and14(eq20(researchRunQueries.id, row.id), eq20(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
+        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and14(eq21(researchRunQueries.id, row.id), eq21(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);
@@ -12087,7 +12137,7 @@ async function executeResearchRun(db, registry, runId, projectId) {
           citationState: determineCitationState(normalized, domains),
           rawResponse: raw.rawResponse,
           finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(and14(eq20(researchRunQueries.id, row.id), eq20(researchRunQueries.status, ResearchQueryStatuses.running))).run();
+        }).where(and14(eq21(researchRunQueries.id, row.id), eq21(researchRunQueries.status, ResearchQueryStatuses.running))).run();
         if (completed.changes === 1) incrementResearchProgress(db, runId, "completedQueries");
       } catch (error) {
         try {
@@ -12111,18 +12161,18 @@ async function executeResearchRun(db, registry, runId, projectId) {
   }
 }
 function incrementResearchProgress(db, runId, column) {
-  db.update(researchRuns).set({ [column]: sql8`${researchRuns[column]} + 1` }).where(eq20(researchRuns.id, runId)).run();
+  db.update(researchRuns).set({ [column]: sql8`${researchRuns[column]} + 1` }).where(eq21(researchRuns.id, runId)).run();
 }
 function markResearchQueryFailed(db, runId, queryId, error) {
   const message = error instanceof Error ? error.message : String(error);
-  const failed = db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and14(eq20(researchRunQueries.id, queryId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+  const failed = db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and14(eq21(researchRunQueries.id, queryId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
   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(and14(eq20(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and14(eq21(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
 }
 function finalizeResearchRun(db, runId, fatalError) {
-  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq20(researchRunQueries.researchRunId, runId)).all();
+  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq21(researchRunQueries.researchRunId, runId)).all();
   const completed = rows.filter((row) => row.status === ResearchQueryStatuses.completed).length;
   const failed = rows.filter((row) => row.status === ResearchQueryStatuses.failed).length;
   db.update(researchRuns).set({
@@ -12131,7 +12181,7 @@ function finalizeResearchRun(db, runId, fatalError) {
     failedQueries: failed,
     error: fatalError ?? (failed === rows.length ? "Every research query failed." : null),
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq20(researchRuns.id, runId)).run();
+  }).where(eq21(researchRuns.id, runId)).run();
 }
 
 // src/server.ts
@@ -12194,14 +12244,14 @@ function summarizeProviderConfig(config) {
   };
 }
 function hashApiKey(key) {
-  return crypto22.createHash("sha256").update(key).digest("hex");
+  return crypto23.createHash("sha256").update(key).digest("hex");
 }
 var DASHBOARD_SCRYPT_KEYLEN = 64;
 var DASHBOARD_SCRYPT_COST = 1 << 15;
 var DASHBOARD_SCRYPT_MAXMEM = 64 * 1024 * 1024;
 function hashDashboardPassword(password) {
-  const salt = crypto22.randomBytes(16);
-  const derived = crypto22.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
+  const salt = crypto23.randomBytes(16);
+  const derived = crypto23.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
     N: DASHBOARD_SCRYPT_COST,
     maxmem: DASHBOARD_SCRYPT_MAXMEM
   });
@@ -12222,14 +12272,14 @@ function verifyDashboardPassword(password, storedHash) {
     } catch {
       return { ok: false, needsRehash: false };
     }
-    const derived = crypto22.scryptSync(password, salt, expected.length, {
+    const derived = crypto23.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: crypto22.timingSafeEqual(derived, expected),
+      ok: crypto23.timingSafeEqual(derived, expected),
       needsRehash: false
     };
   }
@@ -12238,7 +12288,7 @@ function verifyDashboardPassword(password, storedHash) {
     const expected = Buffer.from(storedHash, "hex");
     if (candidate.length !== expected.length)
       return { ok: false, needsRehash: false };
-    const ok = crypto22.timingSafeEqual(candidate, expected);
+    const ok = crypto23.timingSafeEqual(candidate, expected);
     return { ok, needsRehash: ok };
   }
   return { ok: false, needsRehash: false };
@@ -12446,7 +12496,7 @@ async function createServer(opts) {
     (runId, projectId, result) => notifier.dispatchInsightWebhooks(runId, projectId, result),
     async (ctx) => {
       if (!sessionRegistry) return;
-      const project = opts.db.select({ name: projects.name }).from(projects).where(eq21(projects.id, ctx.projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq22(projects.id, ctx.projectId)).get();
       if (!project) return;
       let content;
       if (ctx.kind === RunKinds["aeo-discover-probe"]) {
@@ -12789,7 +12839,7 @@ async function createServer(opts) {
       void (async () => {
         try {
           const report = await aeroClient.runDoctor({ project: projectName });
-          const project = opts.db.select().from(projects).where(eq21(projects.name, projectName)).get();
+          const project = opts.db.select().from(projects).where(eq22(projects.name, projectName)).get();
           if (!project) {
             app.log.warn({ projectName }, "doctor schedule fired for an unknown project");
             return;
@@ -12818,8 +12868,8 @@ async function createServer(opts) {
         if (!probed) return;
         const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(
           and15(
-            eq21(ccReleaseSyncs.release, probed.release),
-            eq21(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
+            eq22(ccReleaseSyncs.release, probed.release),
+            eq22(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
           )
         ).limit(1).get();
         if (alreadySynced) {
@@ -12974,7 +13024,7 @@ async function createServer(opts) {
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto22.randomBytes(32).toString("hex");
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto23.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
@@ -13049,11 +13099,11 @@ async function createServer(opts) {
   const googlePublicUrl = resolveGooglePublicUrl(opts.config, basePath);
   if (opts.config.apiKey) {
     const keyHash = hashApiKey(opts.config.apiKey);
-    const existing = opts.db.select().from(apiKeys).where(eq21(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto22.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto23.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -13077,7 +13127,7 @@ async function createServer(opts) {
   };
   const createSession = (apiKeyId) => {
     pruneExpiredSessions();
-    const sessionId = crypto22.randomBytes(32).toString("hex");
+    const sessionId = crypto23.randomBytes(32).toString("hex");
     sessions.set(sessionId, {
       apiKeyId,
       expiresAt: Date.now() + SESSION_TTL_MS
@@ -13101,7 +13151,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq21(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -13125,7 +13175,7 @@ async function createServer(opts) {
     if (!header) return false;
     const parts = header.split(" ");
     if (parts.length !== 2 || parts[0] !== "Bearer") return false;
-    const key = opts.db.select().from(apiKeys).where(eq21(apiKeys.keyHash, hashApiKey(parts[1]))).get();
+    const key = opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, hashApiKey(parts[1]))).get();
     return Boolean(key && !key.revokedAt);
   };
   const namedAccountsInUse = () => anyUsersExist(opts.db);
@@ -13215,12 +13265,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq21(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq22(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(eq21(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header(
         "set-cookie",
@@ -13433,7 +13483,7 @@ async function createServer(opts) {
         deps: {
           enqueueAutoExtract: ({ projectId, release: r }) => {
             const now = (/* @__PURE__ */ new Date()).toISOString();
-            const runId = crypto22.randomUUID();
+            const runId = crypto23.randomUUID();
             opts.db.insert(runs).values({
               id: runId,
               projectId,
@@ -13558,7 +13608,7 @@ async function createServer(opts) {
         ...inspectOpts,
         config: opts.config
       }).then(() => {
-        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq21(runs.id, runId)).get();
+        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq22(runs.id, runId)).get();
         if (finished?.status === RunStatuses.completed || finished?.status === RunStatuses.partial) {
           return maybeRefreshGscCoverage(opts.db, opts.config, projectId);
         }
@@ -13653,7 +13703,7 @@ async function createServer(opts) {
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         opts.db.insert(auditLog).values(
           targetProjectIds.map((projectId) => ({
-            id: crypto22.randomUUID(),
+            id: crypto23.randomUUID(),
             projectId,
             actor: "api",
             action: existing ? "provider.updated" : "provider.created",
@@ -13921,7 +13971,7 @@ async function createServer(opts) {
   }
   checkLatestVersionForServer();
   scheduler.start();
-  for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq21(researchRuns.status, ResearchRunStatuses.queued)).all()) {
+  for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq22(researchRuns.status, ResearchRunStatuses.queued)).all()) {
     dispatchResearchRun(run.id, run.projectId);
   }
   app.addHook("onClose", async () => {