@canonry/canonry 4.129.1 → 4.130.0

package/dist/{chunk-GYAKRVE2.js → chunk-QR5U2K3O.js}

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-WWZE7VDQ.js";
+} from "./chunk-WIALMCXM.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -110,13 +110,15 @@ import {
   readInstalledVersion,
   redactNotificationUrl,
   refreshAccessToken,
+  researchRunQueries,
+  researchRuns,
   resolveWebhookTarget,
   runs,
   schedules,
   siteAuditPages,
   siteAuditSnapshots,
   usageCounters
-} from "./chunk-LPEE5AYY.js";
+} from "./chunk-5XU6WEMK.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -133,6 +135,8 @@ import {
   LlmCapabilities,
   MemorySources,
   ProviderNames,
+  ResearchQueryStatuses,
+  ResearchRunStatuses,
   RunKinds,
   RunStatuses,
   RunTriggers,
@@ -172,6 +176,7 @@ import {
   isBrowserProvider,
   isGhostTelemetryEvent,
   isRetryableHttpError,
+  mapWithConcurrency,
   normalizeIdTokens,
   normalizeServedModel,
   normalizeUrlPath,
@@ -186,7 +191,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-K4FDDCYG.js";
+} from "./chunk-NVRJZU6V.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -478,11 +483,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 and14, eq as eq20 } from "drizzle-orm";
+import { and as and16, eq as eq22 } from "drizzle-orm";
 import Fastify from "fastify";
 import os5 from "os";
 
@@ -3093,11 +3098,11 @@ function removeWordpressConnection(config, projectName) {
 }
 
 // src/job-runner.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 import fs2 from "fs";
 import path3 from "path";
 import os3 from "os";
-import { and, eq, inArray, sql } from "drizzle-orm";
+import { and as and2, eq as eq2, inArray, sql as sql2 } from "drizzle-orm";
 
 // src/run-telemetry.ts
 import crypto2 from "crypto";
@@ -3139,14 +3144,7 @@ function buildRunCompletedProps(input) {
   return props;
 }
 
-// src/job-runner.ts
-var log = createLogger("JobRunner");
-var RunCancelledError = class extends Error {
-  constructor(runId) {
-    super(`Run ${runId} was cancelled`);
-    this.name = "RunCancelledError";
-  }
-};
+// src/provider-execution-gate.ts
 var ProviderExecutionGate = class {
   constructor(maxConcurrency, maxPerMinute) {
     this.maxConcurrency = maxConcurrency;
@@ -3172,15 +3170,12 @@ var ProviderExecutionGate = class {
       this.inFlight++;
       return;
     }
-    await new Promise((resolve) => {
-      this.waiters.push(resolve);
-    });
+    await new Promise((resolve) => this.waiters.push(resolve));
     this.inFlight++;
   }
   release() {
     this.inFlight = Math.max(0, this.inFlight - 1);
-    const next = this.waiters.shift();
-    next?.();
+    this.waiters.shift()?.();
   }
   async waitForRateLimit() {
     let releaseChain;
@@ -3192,18 +3187,11 @@ var ProviderExecutionGate = class {
     try {
       const now = Date.now();
       const windowStart = now - 6e4;
-      while (this.window.length > 0 && this.window[0] < windowStart) {
-        this.window.shift();
-      }
+      while (this.window.length > 0 && this.window[0] < windowStart) this.window.shift();
       if (this.window.length >= this.maxPerMinute) {
-        const oldestInWindow = this.window[0];
-        const waitMs = oldestInWindow + 6e4 - now + 50;
-        await new Promise((resolve) => setTimeout(resolve, waitMs));
-        const nowAfterWait = Date.now();
-        const newWindowStart = nowAfterWait - 6e4;
-        while (this.window.length > 0 && this.window[0] < newWindowStart) {
-          this.window.shift();
-        }
+        await new Promise((resolve) => setTimeout(resolve, this.window[0] + 6e4 - now + 50));
+        const nextWindowStart = Date.now() - 6e4;
+        while (this.window.length > 0 && this.window[0] < nextWindowStart) this.window.shift();
       }
       this.window.push(Date.now());
     } finally {
@@ -3211,6 +3199,51 @@ var ProviderExecutionGate = class {
     }
   }
 };
+
+// src/usage-quota.ts
+import crypto3 from "crypto";
+import { and, eq, lte, sql } from "drizzle-orm";
+function getCurrentUsageDay() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function reserveDailyQueryQuota(db, input) {
+  if (input.count <= 0) return { reserved: true, used: 0 };
+  if (input.count > input.limit) return { reserved: false, used: 0 };
+  return db.transaction((tx) => {
+    const reserveExisting = () => tx.update(usageCounters).set({ count: sql`${usageCounters.count} + ${input.count}`, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and(
+      eq(usageCounters.scope, input.scope),
+      eq(usageCounters.period, input.period),
+      eq(usageCounters.metric, "queries"),
+      lte(usageCounters.count, input.limit - input.count)
+    )).run();
+    if (reserveExisting().changes === 1) return { reserved: true, used: 0 };
+    const inserted = tx.insert(usageCounters).values({
+      id: crypto3.randomUUID(),
+      scope: input.scope,
+      period: input.period,
+      metric: "queries",
+      count: input.count,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }).onConflictDoNothing().run();
+    if (inserted.changes === 1) return { reserved: true, used: 0 };
+    if (reserveExisting().changes === 1) return { reserved: true, used: 0 };
+    const row = tx.select({ count: usageCounters.count }).from(usageCounters).where(and(eq(usageCounters.scope, input.scope), eq(usageCounters.period, input.period), eq(usageCounters.metric, "queries"))).get();
+    return { reserved: false, used: row?.count ?? 0 };
+  });
+}
+function releaseDailyQueryQuota(db, input) {
+  if (input.count <= 0) return;
+  db.update(usageCounters).set({ count: sql`MAX(0, ${usageCounters.count} - ${input.count})`, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and(eq(usageCounters.scope, input.scope), eq(usageCounters.period, input.period), eq(usageCounters.metric, "queries"))).run();
+}
+
+// src/job-runner.ts
+var log = createLogger("JobRunner");
+var RunCancelledError = class extends Error {
+  constructor(runId) {
+    super(`Run ${runId} was cancelled`);
+    this.name = "RunCancelledError";
+  }
+};
 async function runWithConcurrency(items, limit, worker) {
   if (items.length === 0) return;
   const cap = Math.max(1, Math.min(limit, items.length));
@@ -3288,7 +3321,7 @@ var JobRunner = class {
     if (stale.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const run of stale) {
-      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq(runs.id, run.id)).run();
+      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq2(runs.id, run.id)).run();
       log.warn("run.recovered-stale", { runId: run.id, previousStatus: run.status });
     }
   }
@@ -3303,6 +3336,7 @@ var JobRunner = class {
     let runTrigger;
     let canonicalDomain;
     const providerDispatchCounts = /* @__PURE__ */ new Map();
+    const providerReservations = /* @__PURE__ */ new Map();
     try {
       const existingRun = this.getRunState(runId);
       if (!existingRun) {
@@ -3322,10 +3356,10 @@ var JobRunner = class {
         throw new Error(`Run ${runId} is not executable from status '${existingRun.status}'`);
       }
       if (existingRun.status === "queued") {
-        this.db.update(runs).set({ status: "running", startedAt: now }).where(and(eq(runs.id, runId), eq(runs.status, "queued"))).run();
+        this.db.update(runs).set({ status: "running", startedAt: now }).where(and2(eq2(runs.id, runId), eq2(runs.status, "queued"))).run();
       }
       this.throwIfRunCancelled(runId);
-      const project = this.db.select().from(projects).where(eq(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq2(projects.id, projectId)).get();
       if (!project) {
         throw new Error(`Project ${projectId} not found`);
       }
@@ -3350,8 +3384,8 @@ var JobRunner = class {
       }
       log.info("run.dispatch", { runId, providerCount: activeProviders.length, providers: activeProviders.map((p) => p.adapter.name) });
       const scopedQueryNames = existingRun.queries;
-      projectQueries = scopedQueryNames ? this.db.select().from(queries).where(and(eq(queries.projectId, projectId), inArray(queries.query, scopedQueryNames))).all() : this.db.select().from(queries).where(eq(queries.projectId, projectId)).all();
-      const projectCompetitors = this.db.select().from(competitors).where(eq(competitors.projectId, projectId)).all();
+      projectQueries = scopedQueryNames ? this.db.select().from(queries).where(and2(eq2(queries.projectId, projectId), inArray(queries.query, scopedQueryNames))).all() : this.db.select().from(queries).where(eq2(queries.projectId, projectId)).all();
+      const projectCompetitors = this.db.select().from(competitors).where(eq2(competitors.projectId, projectId)).all();
       const competitorDomains = projectCompetitors.map((c) => c.domain);
       const allDomains = effectiveDomains({
         canonicalDomain: project.canonicalDomain,
@@ -3373,13 +3407,14 @@ var JobRunner = class {
       const todayPeriod = getCurrentUsageDay();
       for (const p of activeProviders) {
         const providerScope = `${projectId}:${p.adapter.name}`;
-        const providerUsage = this.db.select().from(usageCounters).where(eq(usageCounters.scope, providerScope)).all().filter((r) => r.period === todayPeriod && r.metric === "queries").reduce((sum, r) => sum + r.count, 0);
         const limit = p.config.quotaPolicy.maxRequestsPerDay;
-        if (providerUsage + queriesPerProvider > limit) {
+        const quota = reserveDailyQueryQuota(this.db, { scope: providerScope, period: todayPeriod, count: queriesPerProvider, limit });
+        if (!quota.reserved) {
           throw new Error(
-            `Daily quota exceeded for ${p.adapter.name}: ${providerUsage} queries used today, limit is ${limit}. This run needs ${queriesPerProvider} more.`
+            `Daily quota exceeded for ${p.adapter.name}: ${quota.used} queries used today, limit is ${limit}. This run needs ${queriesPerProvider} more.`
           );
         }
+        providerReservations.set(p.adapter.name, { scope: providerScope, period: todayPeriod, reserved: queriesPerProvider });
       }
       const executionGates = /* @__PURE__ */ new Map();
       for (const provider of activeProviders) {
@@ -3434,7 +3469,7 @@ var JobRunner = class {
             );
             let screenshotRelPath = null;
             if (raw.screenshotPath && fs2.existsSync(raw.screenshotPath)) {
-              const snapshotId = crypto3.randomUUID();
+              const snapshotId = crypto4.randomUUID();
               const screenshotDir = path3.join(os3.homedir(), ".canonry", "screenshots", runId);
               if (!fs2.existsSync(screenshotDir)) fs2.mkdirSync(screenshotDir, { recursive: true });
               const destPath = path3.join(screenshotDir, `${snapshotId}.png`);
@@ -3467,7 +3502,7 @@ var JobRunner = class {
               }).run();
             } else {
               this.db.insert(querySnapshots).values({
-                id: crypto3.randomUUID(),
+                id: crypto4.randomUUID(),
                 runId,
                 queryId: q.id,
                 queryText: q.query,
@@ -3523,14 +3558,14 @@ var JobRunner = class {
       const someFailed = providerErrors.size > 0;
       if (allFailed) {
         const errorDetail = serializeRunError(buildRunErrorFromMessages(providerErrors));
-        this.db.update(runs).set({ status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq2(runs.id, runId)).run();
       } else if (someFailed) {
         const errorDetail = serializeRunError(buildRunErrorFromMessages(providerErrors));
-        this.db.update(runs).set({ status: "partial", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "partial", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq2(runs.id, runId)).run();
       } else {
-        this.db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq2(runs.id, runId)).run();
       }
-      this.flushProviderUsage(projectId, providerDispatchCounts);
+      this.flushProviderUsage(providerDispatchCounts, providerReservations);
       const finalStatus = allFailed ? "failed" : someFailed ? "partial" : "completed";
       const failureCode = providerErrors.size > 0 ? classifyProviderErrors(providerErrors) : void 0;
       const phases = buildPhases({ startTime, providerCallStart, providerCallEnd });
@@ -3565,7 +3600,7 @@ var JobRunner = class {
         ...canonicalDomain ? { canonicalDomain } : {}
       };
       if (err instanceof RunCancelledError || this.isRunCancelled(runId)) {
-        this.flushProviderUsage(projectId, providerDispatchCounts);
+        this.flushProviderUsage(providerDispatchCounts, providerReservations);
         this.handleCancelledRun(runId, projectId, startTime, executionContext);
         return;
       }
@@ -3574,8 +3609,8 @@ var JobRunner = class {
         status: "failed",
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: errorMessage
-      }).where(eq(runs.id, runId)).run();
-      this.flushProviderUsage(projectId, providerDispatchCounts);
+      }).where(eq2(runs.id, runId)).run();
+      this.flushProviderUsage(providerDispatchCounts, providerReservations);
       const abortReason = classifyRunAbortReason(errorMessage);
       const phases = buildPhases({ startTime, providerCallStart, providerCallEnd });
       if (abortReason) {
@@ -3619,7 +3654,7 @@ var JobRunner = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const period = now.slice(0, 10);
     this.db.insert(usageCounters).values({
-      id: crypto3.randomUUID(),
+      id: crypto4.randomUUID(),
       scope,
       period,
       metric,
@@ -3627,14 +3662,15 @@ var JobRunner = class {
       updatedAt: now
     }).onConflictDoUpdate({
       target: [usageCounters.scope, usageCounters.period, usageCounters.metric],
-      set: { count: sql`${usageCounters.count} + ${count}`, updatedAt: now }
+      set: { count: sql2`${usageCounters.count} + ${count}`, updatedAt: now }
     }).run();
   }
-  flushProviderUsage(projectId, providerDispatchCounts) {
-    for (const [providerName, count] of providerDispatchCounts.entries()) {
-      if (count <= 0) continue;
-      this.incrementUsage(`${projectId}:${providerName}`, "queries", count);
+  flushProviderUsage(providerDispatchCounts, providerReservations) {
+    for (const [providerName, reservation] of providerReservations.entries()) {
+      const dispatched = providerDispatchCounts.get(providerName) ?? 0;
+      releaseDailyQueryQuota(this.db, { scope: reservation.scope, period: reservation.period, count: Math.max(0, reservation.reserved - dispatched) });
     }
+    providerReservations.clear();
   }
   getRunState(runId) {
     return this.db.select({
@@ -3643,7 +3679,7 @@ var JobRunner = class {
       error: runs.error,
       trigger: runs.trigger,
       queries: runs.queries
-    }).from(runs).where(eq(runs.id, runId)).get();
+    }).from(runs).where(eq2(runs.id, runId)).get();
   }
   isRunCancelled(runId) {
     return this.getRunState(runId)?.status === "cancelled";
@@ -3659,7 +3695,7 @@ var JobRunner = class {
       this.db.update(runs).set({
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: currentRun.error ?? "Cancelled by user"
-      }).where(eq(runs.id, runId)).run();
+      }).where(eq2(runs.id, runId)).run();
     }
     trackEvent(
       "run.completed",
@@ -3682,9 +3718,6 @@ var JobRunner = class {
     }
   }
 };
-function getCurrentUsageDay() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-}
 function buildPhases(input) {
   const total_ms = Date.now() - input.startTime;
   if (input.providerCallStart === void 0) {
@@ -3696,8 +3729,8 @@ function buildPhases(input) {
 }
 
 // src/gsc-sync.ts
-import crypto4 from "crypto";
-import { eq as eq2, and as and2, sql as sql2 } from "drizzle-orm";
+import crypto5 from "crypto";
+import { eq as eq3, and as and3, sql as sql3 } from "drizzle-orm";
 
 // src/gsc-inspect-paced.ts
 var INSPECT_BASE_DELAY_MS = 1e3;
@@ -3774,13 +3807,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(eq2(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq3(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(eq2(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq3(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -3815,10 +3848,10 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     log2.info("fetch.complete", { runId, projectId, rowCount: rows.length });
     db.delete(gscSearchData).where(
-      and2(
-        eq2(gscSearchData.projectId, projectId),
-        sql2`${gscSearchData.date} >= ${startDate}`,
-        sql2`${gscSearchData.date} <= ${endDate}`
+      and3(
+        eq3(gscSearchData.projectId, projectId),
+        sql3`${gscSearchData.date} >= ${startDate}`,
+        sql3`${gscSearchData.date} <= ${endDate}`
       )
     ).run();
     const batchSize = 500;
@@ -3828,7 +3861,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: crypto4.randomUUID(),
+          id: crypto5.randomUUID(),
           projectId,
           syncRunId: runId,
           date: date ?? "",
@@ -3850,17 +3883,17 @@ async function executeGscSync(db, runId, projectId, opts) {
       dimensions: ["date"]
     });
     db.delete(gscDailyTotals).where(
-      and2(
-        eq2(gscDailyTotals.projectId, projectId),
-        sql2`${gscDailyTotals.date} >= ${startDate}`,
-        sql2`${gscDailyTotals.date} <= ${endDate}`
+      and3(
+        eq3(gscDailyTotals.projectId, projectId),
+        sql3`${gscDailyTotals.date} >= ${startDate}`,
+        sql3`${gscDailyTotals.date} <= ${endDate}`
       )
     ).run();
     const dailyTotalsNow = (/* @__PURE__ */ new Date()).toISOString();
     for (const row of totalRows) {
       const [date] = row.keys;
       db.insert(gscDailyTotals).values({
-        id: crypto4.randomUUID(),
+        id: crypto5.randomUUID(),
         projectId,
         date: date ?? "",
         clicks: row.clicks,
@@ -3876,10 +3909,10 @@ async function executeGscSync(db, runId, projectId, opts) {
       dimensions: ["date", "query"]
     });
     db.delete(gscQueryDailyTotals).where(
-      and2(
-        eq2(gscQueryDailyTotals.projectId, projectId),
-        sql2`${gscQueryDailyTotals.date} >= ${startDate}`,
-        sql2`${gscQueryDailyTotals.date} <= ${endDate}`
+      and3(
+        eq3(gscQueryDailyTotals.projectId, projectId),
+        sql3`${gscQueryDailyTotals.date} >= ${startDate}`,
+        sql3`${gscQueryDailyTotals.date} <= ${endDate}`
       )
     ).run();
     const queryTotalsNow = (/* @__PURE__ */ new Date()).toISOString();
@@ -3887,7 +3920,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       const [date, query] = row.keys;
       if (!date || !query) continue;
       db.insert(gscQueryDailyTotals).values({
-        id: crypto4.randomUUID(),
+        id: crypto5.randomUUID(),
         projectId,
         date,
         query,
@@ -3920,7 +3953,7 @@ async function executeGscSync(db, runId, projectId, opts) {
           const rich = ir.richResultsResult;
           const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
           db.insert(gscUrlInspections).values({
-            id: crypto4.randomUUID(),
+            id: crypto5.randomUUID(),
             projectId,
             syncRunId: runId,
             url: pageUrl,
@@ -3957,7 +3990,7 @@ async function executeGscSync(db, runId, projectId, opts) {
         note: "URL inspection stopped early after sustained rate/access failures; search-analytics data was still saved"
       });
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq2(gscUrlInspections.projectId, projectId)).all();
+    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);
@@ -3978,9 +4011,9 @@ async function executeGscSync(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = formatDate(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and2(eq2(gscCoverageSnapshots.projectId, projectId), eq2(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and3(eq3(gscCoverageSnapshots.projectId, projectId), eq3(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
-      id: crypto4.randomUUID(),
+      id: crypto5.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -3989,19 +4022,19 @@ async function executeGscSync(db, runId, projectId, opts) {
       reasonBreakdown: reasonCounts,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }).run();
-    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq2(runs.id, runId)).run();
+    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq3(runs.id, runId)).run();
     log2.info("sync.completed", { runId, projectId, searchDataRows: rows.length, urlInspections: topPages.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(eq2(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq3(runs.id, runId)).run();
     log2.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/gbp-sync.ts
-import crypto5 from "crypto";
-import { eq as eq3, and as and3, desc, inArray as inArray2, lt } from "drizzle-orm";
+import crypto6 from "crypto";
+import { eq as eq4, and as and4, desc, inArray as inArray2, lt } from "drizzle-orm";
 var MS_PER_DAY = 864e5;
 var log3 = createLogger("GbpSync");
 var LOCATION_CONCURRENCY = 4;
@@ -4022,13 +4055,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(eq3(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq4(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(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}`);
     const conn = getGoogleConnection(opts.config, project.canonicalDomain, "gbp");
     if (!conn || !conn.refreshToken) {
@@ -4046,7 +4079,7 @@ async function executeGbpSync(db, runId, projectId, opts) {
       });
       saveConfigPatch(opts.config);
     }
-    let locationRows = db.select().from(gbpLocations).where(and3(eq3(gbpLocations.projectId, projectId), eq3(gbpLocations.selected, true))).all();
+    let locationRows = db.select().from(gbpLocations).where(and4(eq4(gbpLocations.projectId, projectId), eq4(gbpLocations.selected, true))).all();
     if (opts.locationNames?.length) {
       const wanted = new Set(opts.locationNames);
       locationRows = locationRows.filter((l) => wanted.has(l.locationName));
@@ -4096,15 +4129,15 @@ async function executeGbpSync(db, runId, projectId, opts) {
             })))
           ]);
           const lodgingHash = lodging ? hashLodging(lodging) : null;
-          const latestLodging = lodging ? db.select().from(gbpLodgingSnapshots).where(and3(eq3(gbpLodgingSnapshots.projectId, projectId), eq3(gbpLodgingSnapshots.locationName, loc.locationName))).orderBy(desc(gbpLodgingSnapshots.syncedAt)).limit(1).get() : void 0;
+          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 lodgingChanged = lodging !== null && latestLodging?.contentHash !== lodgingHash;
           const attributesHash = hashAttributes(attributes);
-          const latestAttributes = db.select().from(gbpAttributesSnapshots).where(and3(eq3(gbpAttributesSnapshots.projectId, projectId), eq3(gbpAttributesSnapshots.locationName, loc.locationName))).orderBy(desc(gbpAttributesSnapshots.syncedAt)).limit(1).get();
+          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 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(and3(eq3(gbpPlaceDetails.projectId, projectId), eq3(gbpPlaceDetails.locationName, loc.locationName))).orderBy(desc(gbpPlaceDetails.syncedAt)).limit(1).get();
+            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 ageDays = latestPlace ? (Date.now() - new Date(latestPlace.syncedAt).getTime()) / MS_PER_DAY : Infinity;
             if (ageDays >= placesRefreshDays) {
               try {
@@ -4122,10 +4155,10 @@ async function executeGbpSync(db, runId, projectId, opts) {
           }
           const insertNow = (/* @__PURE__ */ new Date()).toISOString();
           db.transaction((tx) => {
-            tx.delete(gbpDailyMetrics).where(and3(eq3(gbpDailyMetrics.projectId, projectId), eq3(gbpDailyMetrics.locationName, loc.locationName))).run();
+            tx.delete(gbpDailyMetrics).where(and4(eq4(gbpDailyMetrics.projectId, projectId), eq4(gbpDailyMetrics.locationName, loc.locationName))).run();
             for (const row of metricRows) {
               tx.insert(gbpDailyMetrics).values({
-                id: crypto5.randomUUID(),
+                id: crypto6.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 date: row.date,
@@ -4134,10 +4167,10 @@ async function executeGbpSync(db, runId, projectId, opts) {
                 syncRunId: runId
               }).run();
             }
-            tx.delete(gbpKeywordImpressions).where(and3(eq3(gbpKeywordImpressions.projectId, projectId), eq3(gbpKeywordImpressions.locationName, loc.locationName))).run();
+            tx.delete(gbpKeywordImpressions).where(and4(eq4(gbpKeywordImpressions.projectId, projectId), eq4(gbpKeywordImpressions.locationName, loc.locationName))).run();
             for (const row of keywordRows) {
               tx.insert(gbpKeywordImpressions).values({
-                id: crypto5.randomUUID(),
+                id: crypto6.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 periodStart: monthKey(keywordsStart),
@@ -4150,15 +4183,15 @@ async function executeGbpSync(db, runId, projectId, opts) {
             }
             const fetchedMonths = monthlyKeywordResults.map((r) => r.month);
             if (fetchedMonths.length > 0) {
-              tx.delete(gbpKeywordMonthly).where(and3(
-                eq3(gbpKeywordMonthly.projectId, projectId),
-                eq3(gbpKeywordMonthly.locationName, loc.locationName),
+              tx.delete(gbpKeywordMonthly).where(and4(
+                eq4(gbpKeywordMonthly.projectId, projectId),
+                eq4(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: crypto5.randomUUID(),
+                    id: crypto6.randomUUID(),
                     projectId,
                     locationName: loc.locationName,
                     month,
@@ -4170,16 +4203,16 @@ async function executeGbpSync(db, runId, projectId, opts) {
                   }).run();
                 }
               }
-              tx.delete(gbpKeywordMonthly).where(and3(
-                eq3(gbpKeywordMonthly.projectId, projectId),
-                eq3(gbpKeywordMonthly.locationName, loc.locationName),
+              tx.delete(gbpKeywordMonthly).where(and4(
+                eq4(gbpKeywordMonthly.projectId, projectId),
+                eq4(gbpKeywordMonthly.locationName, loc.locationName),
                 lt(gbpKeywordMonthly.month, keywordRetentionCutoff)
               )).run();
             }
-            tx.delete(gbpPlaceActions).where(and3(eq3(gbpPlaceActions.projectId, projectId), eq3(gbpPlaceActions.locationName, loc.locationName))).run();
+            tx.delete(gbpPlaceActions).where(and4(eq4(gbpPlaceActions.projectId, projectId), eq4(gbpPlaceActions.locationName, loc.locationName))).run();
             for (const row of placeActionRows) {
               tx.insert(gbpPlaceActions).values({
-                id: crypto5.randomUUID(),
+                id: crypto6.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 placeActionLinkName: row.placeActionLinkName,
@@ -4192,7 +4225,7 @@ async function executeGbpSync(db, runId, projectId, opts) {
             }
             if (lodging !== null && lodgingChanged) {
               tx.insert(gbpLodgingSnapshots).values({
-                id: crypto5.randomUUID(),
+                id: crypto6.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 contentHash: lodgingHash,
@@ -4202,11 +4235,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(eq3(gbpLodgingSnapshots.id, latestLodging.id)).run();
+              tx.update(gbpLodgingSnapshots).set({ syncedAt: insertNow, syncRunId: runId }).where(eq4(gbpLodgingSnapshots.id, latestLodging.id)).run();
             }
             if (attributesChanged) {
               tx.insert(gbpAttributesSnapshots).values({
-                id: crypto5.randomUUID(),
+                id: crypto6.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 contentHash: attributesHash,
@@ -4216,11 +4249,11 @@ async function executeGbpSync(db, runId, projectId, opts) {
                 syncRunId: runId
               }).run();
             } else if (latestAttributes) {
-              tx.update(gbpAttributesSnapshots).set({ syncedAt: insertNow, syncRunId: runId }).where(eq3(gbpAttributesSnapshots.id, latestAttributes.id)).run();
+              tx.update(gbpAttributesSnapshots).set({ syncedAt: insertNow, syncRunId: runId }).where(eq4(gbpAttributesSnapshots.id, latestAttributes.id)).run();
             }
             if (placeToWrite) {
               tx.insert(gbpPlaceDetails).values({
-                id: crypto5.randomUUID(),
+                id: crypto6.randomUUID(),
                 projectId,
                 locationName: loc.locationName,
                 placeId: placeToWrite.placeId,
@@ -4231,9 +4264,9 @@ async function executeGbpSync(db, runId, projectId, opts) {
                 syncRunId: runId
               }).run();
             } else if (placeToTouch) {
-              tx.update(gbpPlaceDetails).set({ syncedAt: insertNow, syncRunId: runId }).where(eq3(gbpPlaceDetails.id, placeToTouch)).run();
+              tx.update(gbpPlaceDetails).set({ syncedAt: insertNow, syncRunId: runId }).where(eq4(gbpPlaceDetails.id, placeToTouch)).run();
             }
-            tx.update(gbpLocations).set({ syncedAt: insertNow, updatedAt: insertNow }).where(eq3(gbpLocations.id, loc.id)).run();
+            tx.update(gbpLocations).set({ syncedAt: insertNow, updatedAt: insertNow }).where(eq4(gbpLocations.id, loc.id)).run();
           });
           okCount++;
         } catch (err) {
@@ -4244,24 +4277,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(eq3(runs.id, runId)).run();
+      db.update(runs).set({ status: "completed", finishedAt }).where(eq4(runs.id, runId)).run();
     } else if (okCount > 0) {
       db.update(runs).set({
         status: "partial",
         error: serializeRunError(buildRunErrorFromMessages(errors)),
         finishedAt
-      }).where(eq3(runs.id, runId)).run();
+      }).where(eq4(runs.id, runId)).run();
     } else {
       db.update(runs).set({
         status: "failed",
         error: serializeRunError(buildRunErrorFromMessages(errors)),
         finishedAt
-      }).where(eq3(runs.id, runId)).run();
+      }).where(eq4(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(eq3(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
     log3.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -4299,7 +4332,7 @@ async function refreshSelectedLocationProfiles(db, projectId, accessToken, locat
         ...profile,
         updatedAt
       };
-      db.update(gbpLocations).set(update).where(and3(eq3(gbpLocations.projectId, projectId), eq3(gbpLocations.id, row.id))).run();
+      db.update(gbpLocations).set(update).where(and4(eq4(gbpLocations.projectId, projectId), eq4(gbpLocations.id, row.id))).run();
       refreshedRows.set(row.id, { ...row, ...update });
     }
   }
@@ -4307,8 +4340,8 @@ async function refreshSelectedLocationProfiles(db, projectId, accessToken, locat
 }
 
 // src/ads-sync.ts
-import crypto6 from "crypto";
-import { eq as eq4 } from "drizzle-orm";
+import crypto7 from "crypto";
+import { eq as eq5 } from "drizzle-orm";
 
 // ../integration-openai-ads/src/constants.ts
 var OPENAI_ADS_API_BASE = "https://api.ads.openai.com/v1";
@@ -4873,11 +4906,11 @@ function toInsightUpserts(level, entityId, rows) {
 }
 async function executeAdsSync(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq4(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq5(runs.id, runId)).run();
   try {
-    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 connRow = db.select().from(adsConnections).where(eq4(adsConnections.projectId, projectId)).get();
+    const connRow = db.select().from(adsConnections).where(eq5(adsConnections.projectId, projectId)).get();
     if (!connRow) {
       throw new Error('No ads connection found for this project. Run "canonry ads connect" first.');
     }
@@ -4929,7 +4962,7 @@ async function executeAdsSync(db, runId, projectId, opts) {
     );
     const insertNow = (/* @__PURE__ */ new Date()).toISOString();
     db.transaction((tx) => {
-      tx.delete(adsCampaigns).where(eq4(adsCampaigns.projectId, projectId)).run();
+      tx.delete(adsCampaigns).where(eq5(adsCampaigns.projectId, projectId)).run();
       for (const campaign of syncedCampaigns) {
         tx.insert(adsCampaigns).values({
           id: campaign.id,
@@ -4984,7 +5017,7 @@ async function executeAdsSync(db, runId, projectId, opts) {
       }
       for (const upsert of insightUpserts) {
         tx.insert(adsInsightsDaily).values({
-          id: crypto6.randomUUID(),
+          id: crypto7.randomUUID(),
           projectId,
           ...upsert,
           syncRunId: runId
@@ -5011,36 +5044,36 @@ async function executeAdsSync(db, runId, projectId, opts) {
         conversionTrackingConfigured,
         lastSyncedAt: insertNow,
         updatedAt: insertNow
-      }).where(eq4(adsConnections.projectId, projectId)).run();
+      }).where(eq5(adsConnections.projectId, projectId)).run();
     });
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (errors.size === 0) {
-      db.update(runs).set({ status: "completed", finishedAt }).where(eq4(runs.id, runId)).run();
+      db.update(runs).set({ status: "completed", finishedAt }).where(eq5(runs.id, runId)).run();
     } else if (syncedCampaigns.length > 0) {
       db.update(runs).set({
         status: "partial",
         error: serializeRunError(buildRunErrorFromMessages(errors)),
         finishedAt
-      }).where(eq4(runs.id, runId)).run();
+      }).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();
     }
     log4.info("sync.done", { runId, projectId, campaigns: syncedCampaigns.length, insightRows: insightUpserts.length, failed: errors.size });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq4(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: serializeRunError({ message: errorMsg }), finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
     log4.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/gsc-inspect-sitemap.ts
-import crypto7 from "crypto";
-import { eq as eq5, and as and4 } from "drizzle-orm";
+import crypto8 from "crypto";
+import { eq as eq6, and as and5 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var log5 = createLogger("SitemapParser");
@@ -5142,13 +5175,13 @@ async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
 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(eq5(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq6(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(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}`);
     }
@@ -5190,7 +5223,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
           const rich = ir.richResultsResult;
           const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
           db.insert(gscUrlInspections).values({
-            id: crypto7.randomUUID(),
+            id: crypto8.randomUUID(),
             projectId,
             syncRunId: runId,
             url: pageUrl,
@@ -5226,7 +5259,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         `URL inspection aborted after ${INSPECT_FAILFAST_THRESHOLD} consecutive rate/access failures (likely GSC URL Inspection quota exhaustion or property access loss). Last error: ${detail}`
       );
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq5(gscUrlInspections.projectId, projectId)).all();
+    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);
@@ -5247,9 +5280,9 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and4(eq5(gscCoverageSnapshots.projectId, projectId), eq5(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and5(eq6(gscCoverageSnapshots.projectId, projectId), eq6(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
-      id: crypto7.randomUUID(),
+      id: crypto8.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -5259,19 +5292,19 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }).run();
     const status = errors > 0 && inspected > 0 ? "partial" : errors === urls.length ? "failed" : "completed";
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq5(runs.id, runId)).run();
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq6(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(eq5(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq6(runs.id, runId)).run();
     log6.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/bing-inspect-sitemap.ts
-import crypto8 from "crypto";
-import { eq as eq6, desc as desc2 } from "drizzle-orm";
+import crypto9 from "crypto";
+import { eq as eq7, desc as desc2 } from "drizzle-orm";
 var log7 = createLogger("BingInspectSitemap");
 function parseBingDate(value) {
   if (!value) return null;
@@ -5289,9 +5322,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(eq6(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq7(runs.id, runId)).run();
   try {
-    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}`);
     }
@@ -5309,7 +5342,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(eq6(bingUrlInspections.projectId, projectId)).all();
+    const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq7(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", {
@@ -5358,7 +5391,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
           derivedInIndex = false;
         }
         db.insert(bingUrlInspections).values({
-          id: crypto8.randomUUID(),
+          id: crypto9.randomUUID(),
           projectId,
           url: pageUrl,
           httpCode,
@@ -5392,7 +5425,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
         await new Promise((r) => setTimeout(r, 1e3));
       }
     }
-    const allInspections = db.select().from(bingUrlInspections).where(eq6(bingUrlInspections.projectId, projectId)).orderBy(desc2(bingUrlInspections.inspectedAt)).all();
+    const allInspections = db.select().from(bingUrlInspections).where(eq7(bingUrlInspections.projectId, projectId)).orderBy(desc2(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -5416,7 +5449,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: crypto8.randomUUID(),
+      id: crypto9.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -5435,7 +5468,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(eq6(runs.id, runId)).run();
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq7(runs.id, runId)).run();
     log7.info("inspect.completed", {
       runId,
       projectId,
@@ -5449,15 +5482,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(eq6(runs.id, runId)).run();
+    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq7(runs.id, runId)).run();
     log7.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/coverage-refresh.ts
-import crypto9 from "crypto";
-import { and as and5, desc as desc3, eq as eq7, inArray as inArray3 } from "drizzle-orm";
+import crypto10 from "crypto";
+import { and as and6, desc as desc3, eq as eq8, inArray as inArray3 } from "drizzle-orm";
 var log8 = createLogger("CoverageRefresh");
 var COVERAGE_REFRESH_MIN_INTERVAL_MS = 60 * 60 * 1e3;
 var ACTIVE_OR_DONE_STATUSES = [
@@ -5468,16 +5501,16 @@ 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(eq7(projects.id, projectId)).get();
+  const project = db.select({ canonicalDomain: projects.canonicalDomain }).from(projects).where(eq8(projects.id, projectId)).get();
   if (!project) return null;
   const { clientId, clientSecret } = getGoogleAuthConfig(config);
   if (!clientId || !clientSecret) return null;
   const conn = getGoogleConnection(config, project.canonicalDomain, "gsc");
   if (!conn?.refreshToken || !conn.propertyId) return null;
   const recent = db.select({ createdAt: runs.createdAt }).from(runs).where(
-    and5(
-      eq7(runs.projectId, projectId),
-      eq7(runs.kind, RunKinds["inspect-sitemap"]),
+    and6(
+      eq8(runs.projectId, projectId),
+      eq8(runs.kind, RunKinds["inspect-sitemap"]),
       inArray3(runs.status, ACTIVE_OR_DONE_STATUSES)
     )
   ).orderBy(desc3(runs.createdAt)).limit(1).get();
@@ -5488,7 +5521,7 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
       return null;
     }
   }
-  const runId = crypto9.randomUUID();
+  const runId = crypto10.randomUUID();
   db.insert(runs).values({
     id: runId,
     projectId,
@@ -5511,9 +5544,9 @@ async function maybeRefreshGscCoverage(db, config, projectId, deps = defaultDeps
 }
 
 // src/commoncrawl-sync.ts
-import crypto10 from "crypto";
+import crypto11 from "crypto";
 import path4 from "path";
-import { and as and6, eq as eq8, sql as sql3 } from "drizzle-orm";
+import { and as and7, eq as eq9, sql as sql4 } from "drizzle-orm";
 var log9 = createLogger("CommonCrawlSync");
 var INSERT_CHUNK_SIZE = 1e4;
 function defaultDeps2() {
@@ -5539,7 +5572,7 @@ async function executeReleaseSync(db, syncId, opts) {
       phaseDetail: "downloading vertices + edges",
       updatedAt: downloadStartedAt,
       error: null
-    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
     const paths = ccReleasePaths(release);
     const releaseCacheDir = path4.join(deps.cacheDir, release);
     const vertexPath = path4.join(releaseCacheDir, paths.vertexFilename);
@@ -5562,7 +5595,7 @@ async function executeReleaseSync(db, syncId, opts) {
       vertexSha256: vertex.sha256,
       edgesSha256: edges.sha256,
       updatedAt: downloadFinishedAt
-    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
     const allProjects = db.select().from(projects).all();
     const targets = Array.from(new Set(allProjects.map((p) => p.canonicalDomain)));
     let rows = [];
@@ -5578,15 +5611,15 @@ async function executeReleaseSync(db, syncId, opts) {
     }
     const queriedAt = deps.now().toISOString();
     db.transaction((tx) => {
-      tx.delete(backlinkDomains).where(eq8(backlinkDomains.releaseSyncId, syncId)).run();
-      tx.delete(backlinkSummaries).where(eq8(backlinkSummaries.releaseSyncId, syncId)).run();
+      tx.delete(backlinkDomains).where(eq9(backlinkDomains.releaseSyncId, syncId)).run();
+      tx.delete(backlinkSummaries).where(eq9(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: crypto10.randomUUID(),
+            id: crypto11.randomUUID(),
             projectId,
             releaseSyncId: syncId,
             release,
@@ -5606,7 +5639,7 @@ async function executeReleaseSync(db, syncId, opts) {
         const projectRows = rowsByProject.get(p.id) ?? [];
         const summary = computeSummary(projectRows);
         tx.insert(backlinkSummaries).values({
-          id: crypto10.randomUUID(),
+          id: crypto11.randomUUID(),
           projectId: p.id,
           releaseSyncId: syncId,
           source: BacklinkSources.commoncrawl,
@@ -5639,7 +5672,7 @@ async function executeReleaseSync(db, syncId, opts) {
       domainsDiscovered: rows.length,
       updatedAt: finishedAt,
       error: null
-    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
     log9.info("sync.completed", {
       syncId,
       release,
@@ -5669,7 +5702,7 @@ async function executeReleaseSync(db, syncId, opts) {
       error: errorMsg,
       phaseDetail: null,
       updatedAt: finishedAt
-    }).where(eq8(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq9(ccReleaseSyncs.id, syncId)).run();
     log9.error("sync.failed", { syncId, release, error: errorMsg });
     throw err;
   }
@@ -5703,9 +5736,9 @@ function computeSummary(rows) {
 }
 
 // src/backlink-extract.ts
-import crypto11 from "crypto";
+import crypto12 from "crypto";
 import fs3 from "fs";
-import { and as and7, desc as desc4, eq as eq9 } from "drizzle-orm";
+import { and as and8, desc as desc4, eq as eq10 } from "drizzle-orm";
 var log10 = createLogger("BacklinkExtract");
 function defaultDeps3() {
   return {
@@ -5717,13 +5750,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(eq9(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq10(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq9(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq10(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
-    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq9(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq9(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc4(ccReleaseSyncs.createdAt)).limit(1).get();
+    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();
     if (!sync) {
       throw new Error("No ready release sync available \u2014 run `canonry backlinks sync` first");
     }
@@ -5751,15 +5784,15 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     const targetDomain = project.canonicalDomain;
     db.transaction((tx) => {
       tx.delete(backlinkDomains).where(
-        and7(
-          eq9(backlinkDomains.projectId, projectId),
-          eq9(backlinkDomains.source, BacklinkSources.commoncrawl),
-          eq9(backlinkDomains.release, release)
+        and8(
+          eq10(backlinkDomains.projectId, projectId),
+          eq10(backlinkDomains.source, BacklinkSources.commoncrawl),
+          eq10(backlinkDomains.release, release)
         )
       ).run();
       if (rows.length > 0) {
         const values = rows.map((r) => ({
-          id: crypto11.randomUUID(),
+          id: crypto12.randomUUID(),
           projectId,
           releaseSyncId: syncId,
           source: BacklinkSources.commoncrawl,
@@ -5773,7 +5806,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }
       const summary = computeSummary2(rows);
       tx.insert(backlinkSummaries).values({
-        id: crypto11.randomUUID(),
+        id: crypto12.randomUUID(),
         projectId,
         releaseSyncId: syncId,
         source: BacklinkSources.commoncrawl,
@@ -5797,7 +5830,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }).run();
     });
     const finishedAt = deps.now().toISOString();
-    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq9(runs.id, runId)).run();
+    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq10(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);
@@ -5806,7 +5839,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       status: RunStatuses.failed,
       error: errorMsg,
       finishedAt
-    }).where(eq9(runs.id, runId)).run();
+    }).where(eq10(runs.id, runId)).run();
     log10.error("extract.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -5816,8 +5849,8 @@ function computeSummary2(rows) {
 }
 
 // src/bing-backlinks-sync.ts
-import crypto12 from "crypto";
-import { and as and8, eq as eq10 } from "drizzle-orm";
+import crypto13 from "crypto";
+import { and as and9, eq as eq11 } from "drizzle-orm";
 var log11 = createLogger("BingBacklinkSync");
 var DEFAULT_MAX_PAGES = 200;
 var LINK_COUNTS_MAX_PAGES = 50;
@@ -5850,9 +5883,9 @@ function defaultDeps4() {
 async function executeBingBacklinkSync(db, runId, projectId, opts) {
   const deps = { ...defaultDeps4(), ...opts.deps };
   const startedAt = deps.now().toISOString();
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq10(runs.id, runId)).run();
+  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 conn = opts.resolveConnection(project.canonicalDomain);
     if (!conn) throw new Error(`No Bing Webmaster connection for ${project.canonicalDomain}`);
@@ -5896,22 +5929,22 @@ async function executeBingBacklinkSync(db, runId, projectId, opts) {
     const release = bingReleaseId(deps.now());
     const targetDomain = project.canonicalDomain;
     const source = BacklinkSources["bing-webmaster"];
-    const existing = db.select({ id: backlinkSummaries.id }).from(backlinkSummaries).where(and8(
-      eq10(backlinkSummaries.projectId, projectId),
-      eq10(backlinkSummaries.source, source),
-      eq10(backlinkSummaries.release, release)
+    const existing = db.select({ id: backlinkSummaries.id }).from(backlinkSummaries).where(and9(
+      eq11(backlinkSummaries.projectId, projectId),
+      eq11(backlinkSummaries.source, source),
+      eq11(backlinkSummaries.release, release)
     )).get();
     const preserveExisting = pageFailures > 0 && !!existing;
     if (!preserveExisting) {
       db.transaction((tx) => {
-        tx.delete(backlinkDomains).where(and8(
-          eq10(backlinkDomains.projectId, projectId),
-          eq10(backlinkDomains.source, source),
-          eq10(backlinkDomains.release, release)
+        tx.delete(backlinkDomains).where(and9(
+          eq11(backlinkDomains.projectId, projectId),
+          eq11(backlinkDomains.source, source),
+          eq11(backlinkDomains.release, release)
         )).run();
         if (rows.length > 0) {
           tx.insert(backlinkDomains).values(rows.map((r) => ({
-            id: crypto12.randomUUID(),
+            id: crypto13.randomUUID(),
             projectId,
             releaseSyncId: null,
             source,
@@ -5923,7 +5956,7 @@ async function executeBingBacklinkSync(db, runId, projectId, opts) {
           }))).run();
         }
         tx.insert(backlinkSummaries).values({
-          id: crypto12.randomUUID(),
+          id: crypto13.randomUUID(),
           projectId,
           releaseSyncId: null,
           source,
@@ -5949,20 +5982,20 @@ async function executeBingBacklinkSync(db, runId, projectId, opts) {
     const finishedAt = deps.now().toISOString();
     const status = pageFailures > 0 ? RunStatuses.partial : RunStatuses.completed;
     const error = preserveExisting ? `Kept existing ${release} snapshot; ${pageFailures} of ${targetPages.length} inbound-link page fetches failed` : pageFailures > 0 ? `${pageFailures} of ${targetPages.length} inbound-link page fetches failed` : null;
-    db.update(runs).set({ status, error, finishedAt }).where(eq10(runs.id, runId)).run();
+    db.update(runs).set({ status, error, finishedAt }).where(eq11(runs.id, runId)).run();
     log11.info("bing-sync.completed", { runId, projectId, release, rows: rows.length, status, pageFailures, preserveExisting });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     const finishedAt = deps.now().toISOString();
-    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt }).where(eq10(runs.id, runId)).run();
+    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt }).where(eq11(runs.id, runId)).run();
     log11.error("bing-sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // 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 and10, eq as eq12 } from "drizzle-orm";
 var log12 = createLogger("DiscoveryRun");
 var DEFAULT_SEED_COUNT = 30;
 var EMBED_RETRY_MAX_RETRIES = 3;
@@ -6004,11 +6037,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
@@ -6046,7 +6079,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();
     log12.info("discovery.completed", {
       runId: opts.runId,
       sessionId: opts.sessionId,
@@ -6061,7 +6094,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) {
@@ -6310,13 +6343,13 @@ function writeDiscoveryInsight(db, input) {
     totalProbes
   });
   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)
+    tx.update(insights).set({ dismissed: true }).where(and10(
+      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",
@@ -6352,8 +6385,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 log13 = createLogger("SiteAudit");
 var SITE_AUDIT_DEFAULT_PAGE_LIMIT = 500;
@@ -6416,9 +6449,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}`);
     }
@@ -6451,7 +6484,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,
@@ -6480,7 +6513,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,
@@ -6491,7 +6524,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();
     });
     log13.info("completed", {
       runId,
@@ -6503,14 +6536,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();
     log13.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 sql4 } from "drizzle-orm";
+import { and as and11, 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();
@@ -6518,7 +6551,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;
@@ -6526,10 +6559,10 @@ async function backfillAnswerVisibilityCommand(opts) {
   let reparsed = 0;
   let providerErrors = 0;
   if (scopedProjects.length > 0) {
-    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and10(
-      eq13(runs.kind, RunKinds["answer-visibility"]),
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and11(
+      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);
@@ -6537,7 +6570,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({
@@ -6625,7 +6658,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;
@@ -6674,13 +6707,13 @@ 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,
     landingPage: gaTrafficSnapshots.landingPage,
     landingPageNormalized: gaTrafficSnapshots.landingPageNormalized
-  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
+  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and11(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -6695,7 +6728,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++;
       }
     });
@@ -6709,7 +6742,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,
@@ -6746,13 +6779,13 @@ 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,
     landingPage: gaAiReferrals.landingPage,
     landingPageNormalized: gaAiReferrals.landingPageNormalized
-  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
+  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and11(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -6767,7 +6800,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++;
       }
     });
@@ -6781,7 +6814,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,
@@ -6817,10 +6850,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(and11(eq14(runs.kind, RunKinds["answer-visibility"]), eq14(runs.projectId, projectId))).all();
   const runIds = runRows.map((r) => r.id);
   let examined = 0;
   let updated = 0;
@@ -6892,7 +6925,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;
@@ -6907,7 +6940,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;
@@ -6967,7 +7000,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-2QBAGT5X.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-53GUE6EI.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -7126,7 +7159,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`);
   }
@@ -7137,8 +7170,8 @@ async function backfillSnapshotAttributionCommand(opts) {
     process.stderr.write(`Recovering orphan snapshot attribution for "${project.name}"${mode}...
 `);
   }
-  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and10(
-    eq13(auditLog.projectId, project.id),
+  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and11(
+    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);
@@ -7146,8 +7179,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(and11(
+    eq14(runs.projectId, project.id),
     isNull(querySnapshots.queryId),
     isNull(querySnapshots.queryText)
   )).groupBy(runs.id).orderBy(runs.createdAt).all();
@@ -7169,8 +7202,8 @@ async function backfillSnapshotAttributionCommand(opts) {
       provider: querySnapshots.provider,
       createdAt: querySnapshots.createdAt,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).where(and10(
-      eq13(querySnapshots.runId, run.runId),
+    }).from(querySnapshots).where(and11(
+      eq14(querySnapshots.runId, run.runId),
       isNull(querySnapshots.queryId),
       isNull(querySnapshots.queryText)
     )).orderBy(querySnapshots.provider, querySnapshots.createdAt).all();
@@ -7236,7 +7269,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();
       }
     });
   }
@@ -7310,7 +7343,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}".
@@ -7335,8 +7368,8 @@ async function backfillTrafficClassificationCommand(opts) {
     dryRun: isDryRun,
     byBot: {}
   };
-  const unknownCountRow = db.select({ n: sql4`count(*)` }).from(rawEventSamples).where(and10(
-    eq13(rawEventSamples.eventType, "unknown"),
+  const unknownCountRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and11(
+    eq14(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).get();
   result.unknownBefore = Number(unknownCountRow?.n ?? 0);
@@ -7348,8 +7381,8 @@ async function backfillTrafficClassificationCommand(opts) {
     userAgent: rawEventSamples.userAgent,
     pathNormalized: rawEventSamples.pathNormalized,
     status: rawEventSamples.status
-  }).from(rawEventSamples).where(and10(
-    eq13(rawEventSamples.eventType, "unknown"),
+  }).from(rawEventSamples).where(and11(
+    eq14(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).all();
   result.examined = unknownSamples.length;
@@ -7388,7 +7421,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) {
@@ -7416,7 +7449,7 @@ async function backfillTrafficClassificationCommand(opts) {
           aiUserFetchEventsHourly.status
         ],
         set: {
-          hits: sql4`${aiUserFetchEventsHourly.hits} + 1`,
+          hits: sql5`${aiUserFetchEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
@@ -7445,15 +7478,15 @@ async function backfillTrafficClassificationCommand(opts) {
           crawlerEventsHourly.status
         ],
         set: {
-          hits: sql4`${crawlerEventsHourly.hits} + 1`,
+          hits: sql5`${crawlerEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
     }
   }
   if (!isDryRun) {
-    const afterRow = db.select({ n: sql4`count(*)` }).from(rawEventSamples).where(and10(
-      eq13(rawEventSamples.eventType, "unknown"),
+    const afterRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and11(
+      eq14(rawEventSamples.eventType, "unknown"),
       inArray4(rawEventSamples.projectId, projectIds)
     )).get();
     result.unknownAfter = Number(afterRow?.n ?? 0);
@@ -7488,7 +7521,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";
@@ -7543,7 +7576,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 {
@@ -7885,9 +7918,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 } from "drizzle-orm";
+import { and as and12, eq as eq15, inArray as inArray5 } from "drizzle-orm";
 var log14 = createLogger("Scheduler");
 function taskKey(projectId, kind) {
   return `${projectId}::${kind}`;
@@ -7902,7 +7935,7 @@ var Scheduler = class {
   }
   /** Load all enabled schedules from DB and register cron jobs. */
   start() {
-    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);
@@ -7932,7 +7965,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(and12(eq15(schedules.projectId, projectId), eq15(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -7973,21 +8006,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;
     log14.info("cron.registered", { projectId, kind, schedule: label, timezone });
   }
   triggerRun(scheduleId, projectId, kind) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const currentSchedule = this.db.select().from(schedules).where(eq14(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq15(schedules.id, scheduleId)).get();
       if (!currentSchedule || !currentSchedule.enabled) {
         log14.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId, kind);
         return;
       }
       const nextRunAt = nextRunFromCron(currentSchedule.cronExpr, currentSchedule.timezone);
-      const project = this.db.select().from(projects).where(eq14(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
       if (!project) {
         log14.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
         this.remove(projectId, kind);
@@ -8007,7 +8040,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log14.info("traffic-sync.triggered", { projectName: project.name, sourceId });
         this.callbacks.onTrafficSyncRequested(project.name, sourceId);
         return;
@@ -8017,7 +8050,7 @@ var Scheduler = class {
           log14.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,
@@ -8030,7 +8063,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log14.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onGbpSyncRequested(runId2, projectId);
         return;
@@ -8040,17 +8073,17 @@ var Scheduler = class {
           log14.warn("ads-sync.no-callback", { scheduleId, projectId, msg: "host did not register onAdsSyncRequested" });
           return;
         }
-        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and11(
-          eq14(runs.projectId, projectId),
-          eq14(runs.kind, RunKinds["ads-sync"]),
+        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and12(
+          eq15(runs.projectId, projectId),
+          eq15(runs.kind, RunKinds["ads-sync"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (activeAdsRun) {
           log14.info("ads-sync.skipped-active", { projectName: project.name, activeRunId: activeAdsRun.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq14(schedules.id, currentSchedule.id)).run();
+          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,
@@ -8063,7 +8096,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log14.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onAdsSyncRequested(runId2, projectId);
         return;
@@ -8077,7 +8110,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log14.info("data-refresh.triggered", { projectName: project.name });
         this.callbacks.onDataRefreshRequested(project.name);
         return;
@@ -8091,7 +8124,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log14.info("backlinks-sync.triggered", { projectName: project.name });
         this.callbacks.onBacklinksSyncRequested(project.name);
         return;
@@ -8101,17 +8134,17 @@ var Scheduler = class {
           log14.warn("site-audit.no-callback", { scheduleId, projectId, msg: "host did not register onSiteAuditRequested" });
           return;
         }
-        const active = this.db.select({ id: runs.id }).from(runs).where(and11(
-          eq14(runs.projectId, projectId),
-          eq14(runs.kind, RunKinds["site-audit"]),
+        const active = this.db.select({ id: runs.id }).from(runs).where(and12(
+          eq15(runs.projectId, projectId),
+          eq15(runs.kind, RunKinds["site-audit"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (active) {
           log14.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq14(schedules.id, currentSchedule.id)).run();
+          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,
@@ -8124,7 +8157,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq14(schedules.id, currentSchedule.id)).run();
+        }).where(eq15(schedules.id, currentSchedule.id)).run();
         log14.info("site-audit.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onSiteAuditRequested(runId2, projectId);
         return;
@@ -8152,7 +8185,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;
@@ -8160,7 +8193,7 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq14(schedules.id, currentSchedule.id)).run();
+      }).where(eq15(schedules.id, currentSchedule.id)).run();
       const scheduleProviders = currentSchedule.providers;
       const providers = scheduleProviders.length > 0 ? scheduleProviders : void 0;
       log14.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
@@ -8195,8 +8228,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 desc5, and as and13, inArray as inArray6, or } from "drizzle-orm";
+import crypto18 from "crypto";
 var log16 = createLogger("Notifier");
 var Notifier = class {
   db;
@@ -8208,18 +8241,18 @@ var Notifier = class {
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
     log16.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) {
       log16.info("notifications.none-enabled", { projectId });
       return;
     }
     log16.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) {
       log16.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) {
       log16.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
@@ -8266,11 +8299,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;
@@ -8300,12 +8333,12 @@ 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 groupSiblings = this.db.select().from(runs).where(and12(
-      eq15(runs.projectId, projectId),
-      eq15(runs.kind, thisRun.kind),
-      eq15(runs.createdAt, thisRun.createdAt)
+    const groupSiblings = this.db.select().from(runs).where(and13(
+      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 [];
@@ -8321,17 +8354,17 @@ var Notifier = class {
       return candidate.id > best.id ? candidate : best;
     });
     if (winner.id !== runId) return [];
-    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(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
     );
     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"))
+      and13(
+        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();
     const groups = groupRunsByCreatedAt(recentRuns);
@@ -8348,7 +8381,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,
@@ -8415,7 +8448,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}`,
@@ -8428,7 +8461,7 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-import { eq as eq16 } from "drizzle-orm";
+import { eq as eq17 } from "drizzle-orm";
 var log17 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(db, notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
@@ -8444,7 +8477,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) {
       log17.info("probe.skip-side-effects", { runId, projectId, kind });
@@ -8520,7 +8553,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"],
@@ -8562,8 +8595,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";
@@ -9301,7 +9334,7 @@ function buildAeroStateTools(ctx, opts = {}) {
 }
 
 // src/agent/llm-usage.ts
-import crypto18 from "crypto";
+import crypto19 from "crypto";
 var AeroLlmUsageFeatures = {
   turn: "aero.turn"
 };
@@ -9320,7 +9353,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,
@@ -9396,7 +9429,7 @@ function splitAeroAnthropicSystemCachePayload(payload, model) {
 }
 
 // src/agent/tool-usage.ts
-import crypto19 from "crypto";
+import crypto20 from "crypto";
 var AeroToolEventStatuses = {
   success: "success",
   error: "error"
@@ -9459,7 +9492,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,
@@ -9686,8 +9719,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 sql5 } from "drizzle-orm";
+import crypto21 from "crypto";
+import { and as and14, desc as desc6, eq as eq18, like, sql as sql6 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -9701,7 +9734,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(desc6(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -9715,7 +9748,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,
@@ -9732,12 +9765,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(and14(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(and14(eq18(agentMemory.projectId, projectId), eq18(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -9752,7 +9785,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({
@@ -9766,16 +9799,16 @@ function writeCompactionNote(db, args) {
     }).run();
     const sessionPrefix = `${COMPACTION_KEY_PREFIX}${args.sessionId}:`;
     const existing = tx.select({ id: agentMemory.id, updatedAt: agentMemory.updatedAt }).from(agentMemory).where(
-      and13(
-        eq17(agentMemory.projectId, args.projectId),
+      and14(
+        eq18(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
     ).orderBy(desc6(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
-      tx.delete(agentMemory).where(sql5`${agentMemory.id} IN (${sql5.join(stale.map((s) => sql5`${s}`), sql5`, `)})`).run();
+      tx.delete(agentMemory).where(sql6`${agentMemory.id} IN (${sql6.join(stale.map((s) => sql6`${s}`), sql6`, `)})`).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(and14(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");
@@ -10002,7 +10035,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,
@@ -10031,7 +10064,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,
@@ -10236,7 +10269,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) {
@@ -10400,17 +10433,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,
@@ -10423,14 +10456,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;
 }
@@ -10439,7 +10472,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 };
       }
@@ -10463,7 +10496,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" };
     }
   );
@@ -11502,6 +11535,117 @@ function clipText(value, length) {
   return `${value.slice(0, length - 3)}...`;
 }
 
+// src/research-runner.ts
+import { and as and15, eq as eq21, inArray as inArray7, sql as sql7 } 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(and15(eq21(researchRuns.id, runId), eq21(researchRuns.projectId, projectId))).get();
+  if (!run || run.status !== ResearchRunStatuses.queued) return;
+  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(and15(eq21(researchRuns.id, runId), eq21(researchRuns.status, ResearchRunStatuses.queued))).run();
+  if (claim.changes !== 1) return;
+  let reserved = 0;
+  let dispatched = 0;
+  let reservation;
+  let fatalError;
+  const workerPersistenceErrors = [];
+  try {
+    if (!provider || isBrowserProvider(run.provider)) {
+      throw new Error("Configured API provider is unavailable.");
+    }
+    const period = getCurrentUsageDay();
+    const scope = `${projectId}:${run.provider}`;
+    const quota = reserveDailyQueryQuota(db, {
+      scope,
+      period,
+      count: run.totalQueries,
+      limit: provider.config.quotaPolicy.maxRequestsPerDay
+    });
+    if (!quota.reserved) {
+      throw new Error(`Daily quota exceeded for ${run.provider}: ${quota.used} queries used today, limit is ${provider.config.quotaPolicy.maxRequestsPerDay}. This batch needs ${run.totalQueries} more.`);
+    }
+    reserved = run.totalQueries;
+    reservation = { scope, period };
+    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 };
+    const gate = new ProviderExecutionGate(provider.config.quotaPolicy.maxConcurrency, provider.config.quotaPolicy.maxRequestsPerMinute);
+    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(and15(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);
+        });
+        const normalized = provider.adapter.normalizeResult(raw);
+        const completed = db.update(researchRunQueries).set({
+          status: ResearchQueryStatuses.completed,
+          servedModel: raw.servedModel ?? null,
+          answerText: normalized.answerText,
+          groundingSources: normalized.groundingSources,
+          citedDomains: normalized.citedDomains,
+          searchQueries: normalized.searchQueries,
+          answerMentioned: determineAnswerMentioned(normalized.answerText, brands, domains),
+          citationState: determineCitationState(normalized, domains),
+          rawResponse: raw.rawResponse,
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }).where(and15(eq21(researchRunQueries.id, row.id), eq21(researchRunQueries.status, ResearchQueryStatuses.running))).run();
+        if (completed.changes === 1) incrementResearchProgress(db, runId, "completedQueries");
+      } catch (error) {
+        try {
+          markResearchQueryFailed(db, runId, row.id, error);
+        } catch (persistenceError) {
+          workerPersistenceErrors.push(persistenceError instanceof Error ? persistenceError.message : String(persistenceError));
+        }
+      }
+    });
+    if (workerPersistenceErrors.length > 0) {
+      fatalError = `Failed to persist one or more research query results: ${workerPersistenceErrors[0]}`;
+    }
+  } catch (error) {
+    fatalError = error instanceof Error ? error.message : String(error);
+  } finally {
+    if (fatalError) markUnfinishedResearchQueriesFailed(db, runId, fatalError);
+    finalizeResearchRun(db, runId, fatalError);
+    if (reservation && reserved > dispatched) {
+      releaseDailyQueryQuota(db, { ...reservation, count: reserved - dispatched });
+    }
+  }
+}
+function incrementResearchProgress(db, runId, column) {
+  db.update(researchRuns).set({ [column]: sql7`${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(and15(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(and15(eq21(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+}
+function finalizeResearchRun(db, runId, fatalError) {
+  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({
+    status: finalResearchRunStatus(completed, failed),
+    completedQueries: completed,
+    failedQueries: failed,
+    error: fatalError ?? (failed === rows.length ? "Every research query failed." : null),
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).where(eq21(researchRuns.id, runId)).run();
+}
+
 // src/server.ts
 var _require3 = createRequire3(import.meta.url);
 var { version: PKG_VERSION2 } = _require3("../package.json");
@@ -11548,14 +11692,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
   });
@@ -11576,14 +11720,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
     };
   }
@@ -11592,7 +11736,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 };
@@ -11793,7 +11937,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(eq20(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"]) {
@@ -12094,9 +12238,9 @@ async function createServer(opts) {
         });
         if (!probed) return;
         const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(
-          and14(
-            eq20(ccReleaseSyncs.release, probed.release),
-            eq20(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
+          and16(
+            eq22(ccReleaseSyncs.release, probed.release),
+            eq22(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
           )
         ).limit(1).get();
         if (alreadySynced) {
@@ -12117,7 +12261,7 @@ async function createServer(opts) {
           );
         });
       })();
-      const project = opts.db.select().from(projects).where(eq20(projects.name, projectName)).get();
+      const project = opts.db.select().from(projects).where(eq22(projects.name, projectName)).get();
       if (project && bingConnectionStore.getConnection(project.canonicalDomain)) {
         aeroClient.backlinksBingSync(projectName).catch((err) => {
           app.log.error(
@@ -12263,7 +12407,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),
@@ -12336,11 +12480,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(eq20(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,
@@ -12364,7 +12508,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
@@ -12388,7 +12532,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq20(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();
@@ -12412,7 +12556,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(eq20(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);
   };
   app.get(apiPrefix + "/session", async (request, reply) => {
@@ -12489,12 +12633,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq20(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(eq20(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",
@@ -12554,6 +12698,11 @@ async function createServer(opts) {
   const briefContentRecommendation = createRecommendationBriefSynthesizer({
     config: opts.config
   });
+  const dispatchResearchRun = (runId, projectId) => {
+    executeResearchRun(opts.db, registry, runId, projectId).catch((err) => {
+      app.log.error({ runId, err }, "Research run failed");
+    });
+  };
   await app.register(apiRoutes, {
     db: opts.db,
     routePrefix: apiPrefix,
@@ -12677,7 +12826,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,
@@ -12732,6 +12881,7 @@ async function createServer(opts) {
         app.log.error({ runId: input.runId, err }, "Discovery run failed");
       });
     },
+    onResearchRunRequested: dispatchResearchRun,
     // Read issued search queries (fan-out) back out of a stored probe payload.
     // Discovery is Gemini-only today, so the Gemini extractor handles every
     // probe; the provider arg lets a future multi-provider discovery dispatch.
@@ -12808,7 +12958,7 @@ async function createServer(opts) {
         ...inspectOpts,
         config: opts.config
       }).then(() => {
-        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq20(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);
         }
@@ -12901,7 +13051,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",
@@ -13152,6 +13302,9 @@ async function createServer(opts) {
   }
   checkLatestVersionForServer();
   scheduler.start();
+  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 () => {
     scheduler.stop();
   });