@canonry/canonry 4.155.0 → 4.157.0

package/dist/{chunk-YSESZNVT.js → chunk-AEIKAWOW.js}

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-OSHRDV36.js";
+} from "./chunk-KMTRO56O.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -128,12 +128,15 @@ import {
   siteCrawlEdges,
   siteCrawlEventReceipts,
   siteCrawlFindings,
+  siteCrawlGraphEdges,
+  siteCrawlGraphLayouts,
+  siteCrawlGraphNodes,
   siteCrawlPages,
   siteCrawlRunRequests,
   siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-VOL2BSM5.js";
+} from "./chunk-MEBL4EJO.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -162,6 +165,8 @@ import {
   SITE_AUDIT_DEFAULT_PAGE_LIMIT,
   SITE_AUDIT_MAX_EDGE_LIMIT,
   SITE_AUDIT_MAX_PAGE_LIMIT,
+  SITE_CRAWL_GRAPH_MAX_EDGES,
+  SITE_CRAWL_GRAPH_MAX_NODES,
   SKILL_MANIFEST_FILENAME,
   SchedulableRunKinds,
   SkillsClients,
@@ -231,7 +236,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-VIKPFI6F.js";
+} from "./chunk-TRRVBTU5.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -561,12 +566,12 @@ function checkLatestVersionForServer(opts) {
 }
 
 // src/server.ts
-import { createRequire as createRequire3 } from "module";
-import crypto24 from "crypto";
+import { createRequire as createRequire4 } from "module";
+import crypto25 from "crypto";
 import fs8 from "fs";
 import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { and as and16, eq as eq22 } from "drizzle-orm";
+import { and as and17, eq as eq23 } from "drizzle-orm";
 import Fastify from "fastify";
 import os5 from "os";
 
@@ -3162,8 +3167,67 @@ function removeVercelTrafficConnection(config, projectName) {
   return true;
 }
 
-// src/wordpress-config.ts
+// src/cloudflare-traffic-config.ts
+function unsupportedDeliveryMode(deliveryMode) {
+  const label = typeof deliveryMode === "string" ? ` "${deliveryMode}"` : "";
+  return new Error(`Unsupported Cloudflare traffic delivery mode${label}`);
+}
 function ensureConnections6(config) {
+  if (!config.cloudflareTraffic) config.cloudflareTraffic = {};
+  if (!config.cloudflareTraffic.connections) config.cloudflareTraffic.connections = [];
+  return config.cloudflareTraffic.connections;
+}
+function normalizeDirectPushConnection(connection) {
+  const deliveryMode = connection.deliveryMode;
+  if (deliveryMode !== void 0 && deliveryMode !== "direct-push") {
+    throw unsupportedDeliveryMode(deliveryMode);
+  }
+  if (deliveryMode === "direct-push") return connection;
+  return { ...connection, deliveryMode: "direct-push" };
+}
+function getCloudflareTrafficConnection(config, projectName) {
+  const connection = (config.cloudflareTraffic?.connections ?? []).find((c) => c.projectName === projectName);
+  return connection ? normalizeDirectPushConnection(connection) : void 0;
+}
+function getCloudflareTrafficConnectionBySourceId(config, sourceId) {
+  const connection = (config.cloudflareTraffic?.connections ?? []).find((c) => c.sourceId === sourceId);
+  return connection ? normalizeDirectPushConnection(connection) : void 0;
+}
+function upsertCloudflareTrafficConnection(config, connection) {
+  const deliveryMode = connection.deliveryMode;
+  if (deliveryMode !== "direct-push") {
+    throw unsupportedDeliveryMode(deliveryMode);
+  }
+  const connections = ensureConnections6(config);
+  const index = connections.findIndex((c) => c.projectName === connection.projectName);
+  if (index === -1) {
+    connections.push(connection);
+    return connection;
+  }
+  connections[index] = connection;
+  return connection;
+}
+function removeCloudflareTrafficConnection(config, projectName) {
+  const connections = config.cloudflareTraffic?.connections;
+  if (!connections?.length) return false;
+  const next = connections.filter((c) => c.projectName !== projectName);
+  if (next.length === connections.length) return false;
+  if (!config.cloudflareTraffic) return false;
+  config.cloudflareTraffic.connections = next;
+  if (next.length === 0) {
+    delete config.cloudflareTraffic;
+  }
+  return true;
+}
+
+// src/cloudflare-ingest-url.ts
+function buildCloudflareIngestUrlTemplate(config) {
+  const base = (config.publicUrl ?? config.apiUrl).replace(/\/+$/, "");
+  return `${base}/api/v1/projects/{name}/traffic/cloudflare/ingest`;
+}
+
+// src/wordpress-config.ts
+function ensureConnections7(config) {
   if (!config.wordpress) config.wordpress = {};
   if (!config.wordpress.connections) config.wordpress.connections = [];
   return config.wordpress.connections;
@@ -3180,7 +3244,7 @@ function getWordpressConnection(config, projectName) {
   return (config.wordpress?.connections ?? []).find((connection) => connection.projectName === projectName);
 }
 function upsertWordpressConnection(config, connection) {
-  const connections = ensureConnections6(config);
+  const connections = ensureConnections7(config);
   const normalized = normalizeConnection(connection);
   const index = connections.findIndex((entry) => entry.projectName === connection.projectName);
   if (index === -1) {
@@ -4144,7 +4208,7 @@ var JobRunner = class {
       }
     }
   }
-  incrementUsage(scope, metric, count) {
+  incrementUsage(scope, metric, count2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const period = now.slice(0, 10);
     this.db.insert(usageCounters).values({
@@ -4152,11 +4216,11 @@ var JobRunner = class {
       scope,
       period,
       metric,
-      count,
+      count: count2,
       updatedAt: now
     }).onConflictDoUpdate({
       target: [usageCounters.scope, usageCounters.period, usageCounters.metric],
-      set: { count: sql2`${usageCounters.count} + ${count}`, updatedAt: now }
+      set: { count: sql2`${usageCounters.count} + ${count2}`, updatedAt: now }
     }).run();
   }
   flushProviderUsage(providerDispatchCounts, providerReservations) {
@@ -5285,7 +5349,7 @@ async function getAdGroupInsights(apiKey, adGroupId, opts) {
 }
 
 // src/ads-config.ts
-function ensureConnections7(config) {
+function ensureConnections8(config) {
   if (!config.openaiAds) config.openaiAds = {};
   if (!config.openaiAds.connections) config.openaiAds.connections = [];
   return config.openaiAds.connections;
@@ -5294,7 +5358,7 @@ function getOpenAiAdsConnection(config, projectName) {
   return (config.openaiAds?.connections ?? []).find((c) => c.projectName === projectName);
 }
 function upsertOpenAiAdsConnection(config, connection) {
-  const connections = ensureConnections7(config);
+  const connections = ensureConnections8(config);
   const index = connections.findIndex((c) => c.projectName === connection.projectName);
   if (index === -1) {
     connections.push(connection);
@@ -6930,9 +6994,421 @@ function buildDiscoveryInsightTitle(input) {
 }
 
 // src/execute-site-audit.ts
-import crypto16 from "crypto";
-import { and as and10, eq as eq13, sql as sql5 } from "drizzle-orm";
+import crypto17 from "crypto";
+import { and as and11, eq as eq14, sql as sql6 } from "drizzle-orm";
 import { runSiteCrawl } from "@canonry/aeo-audit";
+
+// src/site-crawl-graph-layout.ts
+import crypto16 from "crypto";
+import { createRequire as createRequire3 } from "module";
+import { Worker } from "worker_threads";
+import { and as and10, asc, count, desc as desc6, eq as eq13, isNull, ne as ne2, or, sql as sql5 } from "drizzle-orm";
+import { alias } from "drizzle-orm/sqlite-core";
+var SITE_CRAWL_GRAPH_LAYOUT_VERSION = "site-health-fa2-v1";
+var SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS = 15e3;
+var SITE_CRAWL_GRAPH_SEED_SCALE = 100;
+var graphSourcePage = alias(siteCrawlPages, "layout_graph_source_page");
+var graphTargetPage = alias(siteCrawlPages, "layout_graph_target_page");
+var FORCE_ATLAS_SETTINGS = Object.freeze({
+  adjustSizes: false,
+  barnesHutOptimize: true,
+  barnesHutTheta: 0.5,
+  edgeWeightInfluence: 0.5,
+  gravity: 1,
+  linLogMode: false,
+  outboundAttractionDistribution: false,
+  scalingRatio: 10,
+  slowDown: 10,
+  strongGravityMode: false
+});
+var WORKER_SOURCE = String.raw`
+const {parentPort, workerData} = require('node:worker_threads');
+try {
+  const graphologyModule = require(workerData.graphologyPath);
+  const forceAtlasModule = require(workerData.forceAtlasPath);
+  const MultiDirectedGraph = graphologyModule.MultiDirectedGraph;
+  const forceAtlas2 = forceAtlasModule.default || forceAtlasModule;
+  const graph = new MultiDirectedGraph({allowSelfLoops: true});
+  for (const node of workerData.input.nodes) {
+    graph.addNode(node.nodeKey, {x: node.x, y: node.y});
+  }
+  for (const edge of workerData.input.edges) {
+    graph.addDirectedEdgeWithKey(edge.edgeKey, edge.sourceNodeKey, edge.targetNodeKey, {
+      weight: 1 + Math.log2(Math.max(1, edge.occurrences)),
+    });
+  }
+  if (graph.order > 1 && graph.size > 0) {
+    forceAtlas2.assign(graph, {
+      iterations: workerData.input.iterations,
+      settings: workerData.settings,
+    });
+  }
+  const positions = [];
+  graph.forEachNode((nodeKey, attributes) => {
+    positions.push({nodeKey, x: attributes.x, y: attributes.y});
+  });
+  parentPort.postMessage({ok: true, positions});
+} catch (error) {
+  parentPort.postMessage({
+    ok: false,
+    error: error && typeof error.message === 'string' ? error.message : String(error),
+  });
+}
+`;
+var GraphLayoutTimeoutError = class extends Error {
+  name = "GraphLayoutTimeoutError";
+};
+function hashUnit(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967296;
+}
+function pathSection(path10) {
+  return path10.split("/").filter(Boolean)[0] ?? "__root__";
+}
+function seedSiteCrawlGraphNodes(nodes, rootNodeKey, priorPositions) {
+  return [...nodes].sort((a, b) => a.sampleRank - b.sampleRank || a.nodeKey.localeCompare(b.nodeKey)).map((node) => {
+    const prior = priorPositions?.get(node.nodeKey);
+    if (prior && Number.isFinite(prior.x) && Number.isFinite(prior.y)) {
+      return {
+        ...node,
+        x: prior.x * SITE_CRAWL_GRAPH_SEED_SCALE,
+        y: prior.y * SITE_CRAWL_GRAPH_SEED_SCALE
+      };
+    }
+    if (node.nodeKey === rootNodeKey) return { ...node, x: 0, y: 0 };
+    const section = pathSection(node.path);
+    const sectionAngle = hashUnit(`section:${section}`) * Math.PI * 2;
+    const sectionRadius = section === "__root__" ? 24 : 100;
+    const clusterX = Math.cos(sectionAngle) * sectionRadius;
+    const clusterY = Math.sin(sectionAngle) * sectionRadius;
+    const localAngle = hashUnit(`node-angle:${node.nodeKey}`) * Math.PI * 2;
+    const depth = Math.max(0, Math.min(12, node.depth ?? 4));
+    const localRadius = 4 + depth * 2.5 + Math.sqrt(hashUnit(`node-radius:${node.nodeKey}`)) * 14;
+    return {
+      ...node,
+      x: clusterX + Math.cos(localAngle) * localRadius,
+      y: clusterY + Math.sin(localAngle) * localRadius
+    };
+  });
+}
+function adaptiveForceAtlasIterations(nodeCount, edgeCount) {
+  if (nodeCount <= 100 && edgeCount <= 500) return 100;
+  if (nodeCount <= 500 && edgeCount <= 2500) return 70;
+  if (nodeCount <= 2e3 && edgeCount <= 1e4) return 40;
+  if (nodeCount <= 5e3 && edgeCount <= 2e4) return 24;
+  if (nodeCount <= 1e4 && edgeCount <= 35e3) return 12;
+  return 6;
+}
+async function computeForceAtlasPositions(input, options = {}) {
+  if (input.nodes.length <= 1 || input.edges.length === 0) {
+    return input.nodes.map(({ nodeKey, x, y }) => ({ nodeKey, x, y }));
+  }
+  const requireFromPackage = createRequire3(import.meta.url);
+  const worker = new Worker(WORKER_SOURCE, {
+    eval: true,
+    workerData: {
+      graphologyPath: requireFromPackage.resolve("graphology"),
+      forceAtlasPath: requireFromPackage.resolve("graphology-layout-forceatlas2"),
+      input,
+      settings: FORCE_ATLAS_SETTINGS
+    }
+  });
+  const timeoutMs = options.timeoutMs ?? SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS;
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      void worker.terminate();
+      if (result.error) reject(result.error instanceof Error ? result.error : new Error("Graph layout failed with a non-Error reason", { cause: result.error }));
+      else resolve(result.positions ?? []);
+    };
+    const onAbort = () => finish({ error: options.signal?.reason ?? new DOMException("Layout aborted", "AbortError") });
+    const timer = setTimeout(() => finish({ error: new GraphLayoutTimeoutError(`Graph layout exceeded ${timeoutMs}ms`) }), timeoutMs);
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted) return onAbort();
+    worker.once("message", (message) => {
+      if (!message.ok) finish({ error: new Error(message.error ?? "Graph layout worker failed") });
+      else finish({ positions: message.positions });
+    });
+    worker.once("error", (error) => finish({ error }));
+    worker.once("exit", (code) => {
+      if (code !== 0 && !settled) finish({ error: new Error(`Graph layout worker exited with code ${code}`) });
+    });
+  });
+}
+function normalizePositions(seededNodes, computed, rootNodeKey) {
+  const byKey = new Map(computed.map((position) => [position.nodeKey, position]));
+  if (byKey.size !== seededNodes.length) throw new Error("Graph layout returned an incomplete node set");
+  const root = rootNodeKey ? byKey.get(rootNodeKey) : null;
+  const centerX = root?.x ?? computed.reduce((sum, position) => sum + position.x, 0) / Math.max(1, computed.length);
+  const centerY = root?.y ?? computed.reduce((sum, position) => sum + position.y, 0) / Math.max(1, computed.length);
+  if (!Number.isFinite(centerX) || !Number.isFinite(centerY)) throw new Error("Graph layout returned a non-finite center");
+  let scale = 0;
+  for (const position of computed) {
+    if (!Number.isFinite(position.x) || !Number.isFinite(position.y)) throw new Error("Graph layout returned non-finite coordinates");
+    scale = Math.max(scale, Math.abs(position.x - centerX), Math.abs(position.y - centerY));
+  }
+  scale = scale > 0 ? scale : 1;
+  return seededNodes.map((node) => {
+    const position = byKey.get(node.nodeKey);
+    if (!position) throw new Error(`Graph layout omitted ${node.nodeKey}`);
+    return {
+      nodeKey: node.nodeKey,
+      sampleRank: node.sampleRank,
+      x: Math.round((position.x - centerX) / scale * 1e6) / 1e6,
+      y: Math.round((position.y - centerY) / scale * 1e6) / 1e6
+    };
+  });
+}
+async function layoutSiteCrawlGraphInput(input, options = {}) {
+  options.signal?.throwIfAborted();
+  if (input.nodes.length === 0) {
+    return {
+      state: "unavailable",
+      failureCode: "empty-crawl",
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+  const seeded = seedSiteCrawlGraphNodes(input.nodes, input.rootNodeKey, input.priorPositions);
+  try {
+    const compute = options.computePositions ?? computeForceAtlasPositions;
+    const positions = await compute({
+      nodes: seeded,
+      edges: input.edges,
+      iterations: adaptiveForceAtlasIterations(input.nodes.length, input.edges.length)
+    }, { signal: options.signal, timeoutMs: options.timeoutMs });
+    options.signal?.throwIfAborted();
+    return {
+      state: "ready",
+      layoutVersion: SITE_CRAWL_GRAPH_LAYOUT_VERSION,
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      nodeCount: input.nodes.length,
+      edgeCount: input.edges.length,
+      nodes: normalizePositions(seeded, positions, input.rootNodeKey),
+      edges: input.edges.map((edge, sampleRank) => ({ ...edge, sampleRank }))
+    };
+  } catch (error) {
+    if (options.signal?.aborted) options.signal.throwIfAborted();
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    return {
+      state: "unavailable",
+      failureCode: error instanceof GraphLayoutTimeoutError ? "layout-timeout" : "layout-error",
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+}
+function loadPriorSiteCrawlGraphPositions(db, scope) {
+  const prior = db.select({
+    runId: siteCrawlSnapshots.runId,
+    attemptId: siteCrawlSnapshots.attemptId
+  }).from(siteCrawlSnapshots).innerJoin(siteCrawlGraphLayouts, and10(
+    eq13(siteCrawlGraphLayouts.projectId, siteCrawlSnapshots.projectId),
+    eq13(siteCrawlGraphLayouts.runId, siteCrawlSnapshots.runId),
+    eq13(siteCrawlGraphLayouts.attemptId, siteCrawlSnapshots.attemptId)
+  )).where(and10(
+    eq13(siteCrawlSnapshots.projectId, scope.projectId),
+    ne2(siteCrawlSnapshots.runId, scope.runId),
+    eq13(siteCrawlSnapshots.complete, true),
+    eq13(siteCrawlGraphLayouts.state, "ready"),
+    eq13(siteCrawlGraphLayouts.layoutVersion, SITE_CRAWL_GRAPH_LAYOUT_VERSION)
+  )).orderBy(desc6(siteCrawlSnapshots.createdAt), desc6(siteCrawlSnapshots.id)).limit(1).get();
+  if (!prior?.attemptId) return /* @__PURE__ */ new Map();
+  return new Map(db.select({
+    nodeKey: siteCrawlGraphNodes.nodeKey,
+    x: siteCrawlGraphNodes.x,
+    y: siteCrawlGraphNodes.y
+  }).from(siteCrawlGraphNodes).where(and10(
+    eq13(siteCrawlGraphNodes.projectId, scope.projectId),
+    eq13(siteCrawlGraphNodes.runId, prior.runId),
+    eq13(siteCrawlGraphNodes.attemptId, prior.attemptId)
+  )).all().map((node) => [node.nodeKey, { x: node.x, y: node.y }]));
+}
+async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
+  let totalNodes = 0;
+  let totalEdges = 0;
+  try {
+    const assertNotAborted = () => options.signal?.throwIfAborted();
+    assertNotAborted();
+    const pageScope = [
+      eq13(siteCrawlPages.projectId, scope.projectId),
+      eq13(siteCrawlPages.runId, scope.runId),
+      eq13(siteCrawlPages.attemptId, scope.attemptId)
+    ];
+    const edgeScope = [
+      eq13(siteCrawlEdges.projectId, scope.projectId),
+      eq13(siteCrawlEdges.runId, scope.runId),
+      eq13(siteCrawlEdges.attemptId, scope.attemptId),
+      eq13(siteCrawlEdges.internal, true),
+      eq13(siteCrawlEdges.relation, "anchor")
+    ];
+    totalNodes = db.select({ value: count() }).from(siteCrawlPages).where(and10(...pageScope)).get()?.value ?? 0;
+    assertNotAborted();
+    totalEdges = db.select({ value: count() }).from(siteCrawlEdges).innerJoin(graphSourcePage, and10(
+      eq13(graphSourcePage.projectId, scope.projectId),
+      eq13(graphSourcePage.runId, scope.runId),
+      eq13(graphSourcePage.attemptId, scope.attemptId),
+      eq13(graphSourcePage.nodeKey, siteCrawlEdges.sourceNodeKey)
+    )).innerJoin(graphTargetPage, and10(
+      eq13(graphTargetPage.projectId, scope.projectId),
+      eq13(graphTargetPage.runId, scope.runId),
+      eq13(graphTargetPage.attemptId, scope.attemptId),
+      eq13(graphTargetPage.nodeKey, siteCrawlEdges.targetNodeKey)
+    )).where(and10(...edgeScope)).get()?.value ?? 0;
+    assertNotAborted();
+    const graphSeedColumns = {
+      nodeKey: siteCrawlPages.nodeKey,
+      path: siteCrawlPages.path,
+      depth: siteCrawlPages.depth
+    };
+    const rootRows = db.select(graphSeedColumns).from(siteCrawlPages).where(and10(...pageScope, eq13(siteCrawlPages.url, scope.rootUrl))).orderBy(asc(siteCrawlPages.nodeKey)).limit(1).all();
+    assertNotAborted();
+    const retainedRows = [...rootRows];
+    if (retainedRows.length < SITE_CRAWL_GRAPH_MAX_NODES) {
+      retainedRows.push(...db.select(graphSeedColumns).from(siteCrawlPages).where(and10(...pageScope, eq13(siteCrawlPages.depth, 0), ne2(siteCrawlPages.url, scope.rootUrl))).orderBy(asc(siteCrawlPages.nodeKey)).limit(SITE_CRAWL_GRAPH_MAX_NODES - retainedRows.length).all());
+    }
+    assertNotAborted();
+    if (retainedRows.length < SITE_CRAWL_GRAPH_MAX_NODES) {
+      retainedRows.push(...db.select(graphSeedColumns).from(siteCrawlPages).where(and10(
+        ...pageScope,
+        or(isNull(siteCrawlPages.depth), ne2(siteCrawlPages.depth, 0)),
+        ne2(siteCrawlPages.url, scope.rootUrl)
+      )).orderBy(desc6(siteCrawlPages.linkScoreNormalized), asc(siteCrawlPages.nodeKey)).limit(SITE_CRAWL_GRAPH_MAX_NODES - retainedRows.length).all());
+    }
+    assertNotAborted();
+    const nodes = retainedRows.map((row, sampleRank) => ({
+      nodeKey: row.nodeKey,
+      path: row.path,
+      depth: row.depth,
+      sampleRank
+    }));
+    const rootNodeKey = rootRows[0]?.nodeKey ?? null;
+    const priorPositions = loadPriorSiteCrawlGraphPositions(db, scope);
+    assertNotAborted();
+    const selectedKeys = JSON.stringify(nodes.map((node) => node.nodeKey));
+    const edgeRows = nodes.length === 0 ? [] : db.all(sql5`
+      WITH selected(node_key) AS (SELECT value FROM json_each(${selectedKeys}))
+      SELECT
+        edge.edge_key AS edgeKey,
+        edge.source_node_key AS sourceNodeKey,
+        edge.target_node_key AS targetNodeKey,
+        edge.followable AS followable,
+        edge.occurrences AS occurrences
+      FROM site_crawl_edges AS edge
+      INNER JOIN selected AS source ON source.node_key = edge.source_node_key
+      INNER JOIN selected AS target ON target.node_key = edge.target_node_key
+      WHERE edge.project_id = ${scope.projectId}
+        AND edge.run_id = ${scope.runId}
+        AND edge.attempt_id = ${scope.attemptId}
+        AND edge.internal = 1
+        AND edge.relation = 'anchor'
+      ORDER BY edge.occurrences DESC, edge.edge_key ASC
+      LIMIT ${SITE_CRAWL_GRAPH_MAX_EDGES}
+    `);
+    assertNotAborted();
+    return await layoutSiteCrawlGraphInput({
+      totalNodes,
+      totalEdges,
+      nodes,
+      edges: edgeRows,
+      rootNodeKey,
+      priorPositions
+    }, options);
+  } catch (error) {
+    if (options.signal?.aborted) options.signal.throwIfAborted();
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    return {
+      state: "unavailable",
+      failureCode: "layout-error",
+      totalNodes,
+      totalEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+}
+function persistSiteCrawlGraphLayout(db, scope, layout, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  db.transaction((tx) => {
+    tx.delete(siteCrawlGraphLayouts).where(and10(
+      eq13(siteCrawlGraphLayouts.projectId, scope.projectId),
+      eq13(siteCrawlGraphLayouts.runId, scope.runId),
+      eq13(siteCrawlGraphLayouts.attemptId, scope.attemptId)
+    )).run();
+    tx.insert(siteCrawlGraphLayouts).values({
+      id: crypto16.randomUUID(),
+      projectId: scope.projectId,
+      runId: scope.runId,
+      attemptId: scope.attemptId,
+      state: layout.state,
+      layoutVersion: layout.state === "ready" ? layout.layoutVersion : null,
+      failureCode: layout.state === "unavailable" ? layout.failureCode : null,
+      totalNodes: layout.totalNodes,
+      totalEdges: layout.totalEdges,
+      nodeCount: layout.nodeCount,
+      edgeCount: layout.edgeCount,
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    if (layout.state !== "ready") return;
+    const batchSize = 250;
+    for (let offset = 0; offset < layout.nodes.length; offset += batchSize) {
+      tx.insert(siteCrawlGraphNodes).values(layout.nodes.slice(offset, offset + batchSize).map((node) => ({
+        id: crypto16.randomUUID(),
+        projectId: scope.projectId,
+        runId: scope.runId,
+        attemptId: scope.attemptId,
+        nodeKey: node.nodeKey,
+        sampleRank: node.sampleRank,
+        x: node.x,
+        y: node.y,
+        createdAt: now
+      }))).run();
+    }
+    for (let offset = 0; offset < layout.edges.length; offset += batchSize) {
+      tx.insert(siteCrawlGraphEdges).values(layout.edges.slice(offset, offset + batchSize).map((edge) => ({
+        id: crypto16.randomUUID(),
+        projectId: scope.projectId,
+        runId: scope.runId,
+        attemptId: scope.attemptId,
+        edgeKey: edge.edgeKey,
+        sampleRank: edge.sampleRank,
+        sourceNodeKey: edge.sourceNodeKey,
+        targetNodeKey: edge.targetNodeKey,
+        followable: edge.followable,
+        occurrences: edge.occurrences,
+        createdAt: now
+      }))).run();
+    }
+  });
+}
+function deleteSiteCrawlGraphLayout(db, scope) {
+  db.delete(siteCrawlGraphLayouts).where(and10(
+    eq13(siteCrawlGraphLayouts.projectId, scope.projectId),
+    eq13(siteCrawlGraphLayouts.runId, scope.runId),
+    eq13(siteCrawlGraphLayouts.attemptId, scope.attemptId)
+  )).run();
+}
+
+// src/execute-site-audit.ts
 var log12 = createLogger("SiteAudit");
 var SiteAuditCancelledError = class extends Error {
   name = "SiteAuditCancelledError";
@@ -6956,6 +7432,22 @@ function clampSiteAuditEdgeLimit(limit) {
 function toPageFactor(factor) {
   return { id: factor.id, name: factor.name, weight: factor.weight, score: factor.score };
 }
+function toCrawlAuditFactor(factor) {
+  return {
+    ...toPageFactor(factor),
+    status: factorStatusFromScore(factor.score),
+    applicable: factor.applicable ?? null,
+    findings: factor.findings,
+    recommendations: factor.recommendations
+  };
+}
+function crawlAuditFields(audit) {
+  return {
+    schemaVersion: "1.0",
+    factors: audit.factors.map(toCrawlAuditFactor),
+    criticalDefects: audit.criticalDefects
+  };
+}
 function computeFactorAverages(pages) {
   const byId = /* @__PURE__ */ new Map();
   for (const page of pages) {
@@ -7063,10 +7555,10 @@ function deadLinkCheckedCount(edges, pages) {
 }
 async function executeSiteAudit(db, runId, projectId, opts = {}) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const claim = db.update(runs).set({ status: "running", startedAt }).where(and10(eq13(runs.id, runId), eq13(runs.projectId, projectId), eq13(runs.status, "queued"))).run();
+  const claim = db.update(runs).set({ status: "running", startedAt }).where(and11(eq14(runs.id, runId), eq14(runs.projectId, projectId), eq14(runs.status, "queued"))).run();
   if (claim.changes === 0) return;
-  const attemptNumber = (db.select({ value: sql5`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq13(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
-  const attemptId = crypto16.randomUUID();
+  const attemptNumber = (db.select({ value: sql6`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq14(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
+  const attemptId = crypto17.randomUUID();
   db.insert(siteCrawlAttempts).values({
     id: attemptId,
     projectId,
@@ -7100,30 +7592,30 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       const nodeKey = nodeKeyByUrl.get(url);
       if (!nodeKey) continue;
       const scope = [
-        eq13(siteCrawlEdges.projectId, projectId),
-        eq13(siteCrawlEdges.runId, runId),
-        eq13(siteCrawlEdges.attemptId, attemptId)
+        eq14(siteCrawlEdges.projectId, projectId),
+        eq14(siteCrawlEdges.runId, runId),
+        eq14(siteCrawlEdges.attemptId, attemptId)
       ];
-      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and10(
+      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and11(
         ...scope,
-        eq13(siteCrawlEdges.sourceUrl, url)
+        eq14(siteCrawlEdges.sourceUrl, url)
       )).run();
-      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and10(
+      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and11(
         ...scope,
-        eq13(siteCrawlEdges.targetUrl, url)
+        eq14(siteCrawlEdges.targetUrl, url)
       )).run();
-      tx.update(siteCrawlPages).set({ canonicalNodeKey: nodeKey, updatedAt: now }).where(and10(
-        eq13(siteCrawlPages.projectId, projectId),
-        eq13(siteCrawlPages.runId, runId),
-        eq13(siteCrawlPages.attemptId, attemptId),
-        eq13(siteCrawlPages.canonicalUrl, url)
+      tx.update(siteCrawlPages).set({ canonicalNodeKey: nodeKey, updatedAt: now }).where(and11(
+        eq14(siteCrawlPages.projectId, projectId),
+        eq14(siteCrawlPages.runId, runId),
+        eq14(siteCrawlPages.attemptId, attemptId),
+        eq14(siteCrawlPages.canonicalUrl, url)
       )).run();
     }
   };
   const persistPage = (tx, page, now) => {
     const audit = page.audit;
     tx.insert(siteCrawlPages).values({
-      id: crypto16.randomUUID(),
+      id: crypto17.randomUUID(),
       projectId,
       runId,
       attemptId,
@@ -7151,7 +7643,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       indexabilityReasons: page.indexability.reasons,
       auditState: pageAuditState(page),
       auditScore: audit?.overallScore ?? null,
-      auditFields: audit ? { factors: audit.factors.map(toPageFactor) } : {},
+      auditFields: audit ? crawlAuditFields(audit) : {},
       inventoryEligible: isInventoryEligible(page),
       depth: page.depth,
       inboundUniqueEdges: page.metrics.inbound.uniqueEdges,
@@ -7172,7 +7664,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         discoveryProvenance: [{ discoveredFrom: page.provenance.discoveredFrom, sitemapSources: page.provenance.sitemapSources, root: page.provenance.root }],
         sitemapMetadata: { sources: page.provenance.sitemapSources },
         fetchState: page.state,
-        fetchedAt: page.state === "discovered" || page.state === "robots-blocked" ? null : sql5`coalesce(${siteCrawlPages.fetchedAt}, ${now})`,
+        fetchedAt: page.state === "discovered" || page.state === "robots-blocked" ? null : sql6`coalesce(${siteCrawlPages.fetchedAt}, ${now})`,
         httpStatus: page.statusCode,
         contentType: page.contentType,
         finalUrl: page.finalUrl,
@@ -7184,7 +7676,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         indexabilityReasons: page.indexability.reasons,
         auditState: pageAuditState(page),
         auditScore: audit?.overallScore ?? null,
-        auditFields: audit ? { factors: audit.factors.map(toPageFactor) } : {},
+        auditFields: audit ? crawlAuditFields(audit) : {},
         inventoryEligible: isInventoryEligible(page),
         depth: page.depth,
         inboundUniqueEdges: page.metrics.inbound.uniqueEdges,
@@ -7206,7 +7698,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
   const persistEdge = (tx, edge, now) => {
     observedEdges.set(edge.key, edge);
     tx.insert(siteCrawlEdges).values({
-      id: crypto16.randomUUID(),
+      id: crypto17.randomUUID(),
       projectId,
       runId,
       attemptId,
@@ -7252,20 +7744,20 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       linkScoreRaw: metrics.linkScoreRaw,
       linkScoreNormalized: metrics.linkScore,
       updatedAt: now
-    }).where(and10(
-      eq13(siteCrawlPages.projectId, projectId),
-      eq13(siteCrawlPages.runId, runId),
-      eq13(siteCrawlPages.attemptId, attemptId),
-      eq13(siteCrawlPages.nodeKey, key)
+    }).where(and11(
+      eq14(siteCrawlPages.projectId, projectId),
+      eq14(siteCrawlPages.runId, runId),
+      eq14(siteCrawlPages.attemptId, attemptId),
+      eq14(siteCrawlPages.nodeKey, key)
     )).run();
   };
   const persistEvent = async (event) => {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     db.transaction((tx) => {
-      const receipt = tx.select({ checksum: siteCrawlEventReceipts.checksum }).from(siteCrawlEventReceipts).where(and10(
-        eq13(siteCrawlEventReceipts.attemptId, attemptId),
-        eq13(siteCrawlEventReceipts.sequence, event.sequence),
-        eq13(siteCrawlEventReceipts.batchId, event.batchId)
+      const receipt = tx.select({ checksum: siteCrawlEventReceipts.checksum }).from(siteCrawlEventReceipts).where(and11(
+        eq14(siteCrawlEventReceipts.attemptId, attemptId),
+        eq14(siteCrawlEventReceipts.sequence, event.sequence),
+        eq14(siteCrawlEventReceipts.batchId, event.batchId)
       )).get();
       if (receipt) {
         if (receipt.checksum !== event.checksum) {
@@ -7274,7 +7766,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         return;
       }
       tx.insert(siteCrawlEventReceipts).values({
-        id: crypto16.randomUUID(),
+        id: crypto17.randomUUID(),
         projectId,
         runId,
         attemptId,
@@ -7294,22 +7786,22 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           lastEventChecksum: event.checksum,
           pagesDiscovered: progress.pagesDiscovered,
           pagesFetched: progress.pagesFetched,
-          pagesEligible: event.type === "summary" ? observedPages.size === 0 ? 0 : [...observedPages.values()].filter(isInventoryEligible).length : sql5`${siteCrawlAttempts.pagesEligible}`,
-          pagesErrored: event.type === "summary" ? observedErrorCount(observedPages.values()) : sql5`${siteCrawlAttempts.pagesErrored}`,
+          pagesEligible: event.type === "summary" ? observedPages.size === 0 ? 0 : [...observedPages.values()].filter(isInventoryEligible).length : sql6`${siteCrawlAttempts.pagesEligible}`,
+          pagesErrored: event.type === "summary" ? observedErrorCount(observedPages.values()) : sql6`${siteCrawlAttempts.pagesErrored}`,
           edgesDiscovered: progress.edgesObserved,
           updatedAt: now
-        }).where(eq13(siteCrawlAttempts.id, attemptId)).run();
+        }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
       } else {
         tx.update(siteCrawlAttempts).set({
           lastEventSequence: event.sequence,
           lastEventChecksum: event.checksum,
           updatedAt: now
-        }).where(eq13(siteCrawlAttempts.id, attemptId)).run();
+        }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
       }
     });
   };
   try {
-    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) throw new Error(`Project not found: ${projectId}`);
     const homepageUrl = toHomepageUrl(project.canonicalDomain);
     const maxPages = clampSiteAuditLimit(opts.maxPages ?? opts.limit);
@@ -7332,6 +7824,12 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     if (crawlSummary.complete && !hasAuditedPages) {
       throw emptyCompleteCrawlError(crawlSummary.rootUrl, crawlSummary.finalRootUrl, crawlSummary.pagesObserved);
     }
+    const graphLayout = await prepareSiteCrawlGraphLayout(db, {
+      projectId,
+      runId,
+      attemptId,
+      rootUrl: crawlSummary.finalRootUrl ?? crawlSummary.rootUrl
+    }, { signal: opts.signal, timeoutMs: opts.graphLayoutTimeoutMs });
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     const factors = computeFactorAverages([...observedPages.values()]);
     const errorCount = observedErrorCount(observedPages.values());
@@ -7339,12 +7837,39 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     const deadLinksChecked = opts.checkDeadLinks ? deadLinkCheckedCount(observedEdges.values(), observedPages.values()) : 0;
     const deadLinksFound = report.deadLinks.findings.length;
     const legacyIssues = factors.map((factor) => toLegacyIssue(factor, crawlSummary.auditRollup.auditedPages)).filter((issue) => issue !== null);
+    try {
+      persistSiteCrawlGraphLayout(db, { projectId, runId, attemptId }, graphLayout, finishedAt);
+    } catch (error) {
+      log12.warn("graph-layout.persist-failed", {
+        runId,
+        projectId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      try {
+        persistSiteCrawlGraphLayout(db, { projectId, runId, attemptId }, {
+          state: "unavailable",
+          failureCode: "layout-error",
+          totalNodes: graphLayout.totalNodes,
+          totalEdges: graphLayout.totalEdges,
+          nodeCount: 0,
+          edgeCount: 0,
+          nodes: [],
+          edges: []
+        }, finishedAt);
+      } catch (markerError) {
+        log12.warn("graph-layout.marker-persist-failed", {
+          runId,
+          projectId,
+          error: markerError instanceof Error ? markerError.message : String(markerError)
+        });
+      }
+    }
     const published = db.transaction((tx) => {
-      const claim2 = tx.update(runs).set({ status: terminalStatus, finishedAt }).where(and10(eq13(runs.id, runId), eq13(runs.status, "running"))).run();
+      const claim2 = tx.update(runs).set({ status: terminalStatus, finishedAt }).where(and11(eq14(runs.id, runId), eq14(runs.status, "running"))).run();
       if (claim2.changes === 0) return false;
       if (hasAuditedPages) {
         tx.insert(siteAuditSnapshots).values({
-          id: crypto16.randomUUID(),
+          id: crypto17.randomUUID(),
           projectId,
           runId,
           sitemapUrl: opts.sitemapUrl ?? `${homepageUrl}/sitemap.xml`,
@@ -7362,7 +7887,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         for (const page of observedPages.values()) {
           if (!isLegacyScorecardPage(page)) continue;
           tx.insert(siteAuditPages).values({
-            id: crypto16.randomUUID(),
+            id: crypto17.randomUUID(),
             projectId,
             runId,
             url: page.finalUrl ?? page.requestedUrl,
@@ -7375,11 +7900,12 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         }
       }
       tx.insert(siteCrawlSnapshots).values({
-        id: crypto16.randomUUID(),
+        id: crypto17.randomUUID(),
         projectId,
         runId,
         attemptId,
-        rootUrl: crawlSummary.rootUrl,
+        requestedRootUrl: crawlSummary.rootUrl,
+        rootUrl: crawlSummary.finalRootUrl ?? crawlSummary.rootUrl,
         crawlSchemaVersion: crawlSummary.crawlSchemaVersion,
         engineVersion: crawlSummary.engineVersion,
         normalizationVersion: crawlSummary.urlNormalizationVersion,
@@ -7415,7 +7941,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       if (opts.checkDeadLinks) {
         for (const finding of report.deadLinks.findings) {
           tx.insert(siteCrawlFindings).values({
-            id: crypto16.randomUUID(),
+            id: crypto17.randomUUID(),
             projectId,
             runId,
             attemptId,
@@ -7441,11 +7967,20 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         edgesDiscovered: crawlSummary.edgesObserved,
         finishedAt,
         updatedAt: finishedAt
-      }).where(eq13(siteCrawlAttempts.id, attemptId)).run();
+      }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
       return true;
     });
     if (!published) {
-      const current = db.select({ status: runs.status }).from(runs).where(eq13(runs.id, runId)).get();
+      try {
+        deleteSiteCrawlGraphLayout(db, { projectId, runId, attemptId });
+      } catch (cleanupError) {
+        log12.warn("graph-layout.cleanup-failed", {
+          runId,
+          projectId,
+          error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+        });
+      }
+      const current = db.select({ status: runs.status }).from(runs).where(eq14(runs.id, runId)).get();
       if (current?.status === "cancelled") throw new SiteAuditCancelledError(`Site audit cancelled before publication: ${runId}`);
       throw new Error(`Site audit run was no longer running before publication: ${runId}`);
     }
@@ -7460,12 +7995,12 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         error: message,
         finishedAt,
         updatedAt: finishedAt
-      }).where(eq13(siteCrawlAttempts.id, attemptId)).run();
+      }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
       tx.update(runs).set({
         status: cancelled ? "cancelled" : "failed",
         error: message,
         finishedAt
-      }).where(and10(eq13(runs.id, runId), eq13(runs.status, "running"))).run();
+      }).where(and11(eq14(runs.id, runId), eq14(runs.status, "running"))).run();
     });
     log12.error("failed", { runId, projectId, cancelled, error: message });
     throw error;
@@ -7473,7 +8008,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
 }
 
 // src/commands/backfill.ts
-import { and as and11, eq as eq14, inArray as inArray4, isNull, sql as sql6 } from "drizzle-orm";
+import { and as and12, eq as eq15, inArray as inArray4, isNull as isNull2, sql as sql7 } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
@@ -7481,7 +8016,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(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -7489,10 +8024,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(and11(
-      eq14(runs.kind, RunKinds["answer-visibility"]),
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and12(
+      eq15(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(eq14(runs.kind, RunKinds["answer-visibility"])).all();
+    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq15(runs.kind, RunKinds["answer-visibility"])).all();
     const runIdsByProject = /* @__PURE__ */ new Map();
     for (const run of runRows) {
       const existing = runIdsByProject.get(run.projectId);
@@ -7500,7 +8035,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(eq14(competitors.projectId, project.id)).all().map((row) => row.domain);
+      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq15(competitors.projectId, project.id)).all().map((row) => row.domain);
       const runIds = runIdsByProject.get(project.id) ?? [];
       if (runIds.length === 0) continue;
       const projectDomains = effectiveDomains({
@@ -7593,7 +8128,7 @@ async function backfillAnswerVisibilityCommand(opts) {
           } else {
             db.transaction((tx) => {
               for (const update of pendingUpdates) {
-                tx.update(querySnapshots).set(update.patch).where(eq14(querySnapshots.id, update.id)).run();
+                tx.update(querySnapshots).set(update.patch).where(eq15(querySnapshots.id, update.id)).run();
               }
             });
             updated += pendingUpdates.length;
@@ -7642,13 +8177,13 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 function backfillNormalizedPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq14(gaTrafficSnapshots.projectId, opts.projectId));
+    baseConditions.push(eq15(gaTrafficSnapshots.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaTrafficSnapshots.id,
     landingPage: gaTrafficSnapshots.landingPage,
     landingPageNormalized: gaTrafficSnapshots.landingPageNormalized
-  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and11(...baseConditions) : void 0).all();
+  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and12(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -7663,7 +8198,7 @@ function backfillNormalizedPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq14(gaTrafficSnapshots.id, row.id)).run();
+        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq15(gaTrafficSnapshots.id, row.id)).run();
         updated++;
       }
     });
@@ -7677,7 +8212,7 @@ async function backfillNormalizedPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq14(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq15(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -7714,13 +8249,13 @@ async function backfillNormalizedPathsCommand(opts) {
 function backfillAiReferralPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq14(gaAiReferrals.projectId, opts.projectId));
+    baseConditions.push(eq15(gaAiReferrals.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaAiReferrals.id,
     landingPage: gaAiReferrals.landingPage,
     landingPageNormalized: gaAiReferrals.landingPageNormalized
-  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and11(...baseConditions) : void 0).all();
+  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and12(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -7735,7 +8270,7 @@ function backfillAiReferralPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq14(gaAiReferrals.id, row.id)).run();
+        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq15(gaAiReferrals.id, row.id)).run();
         updated++;
       }
     });
@@ -7749,7 +8284,7 @@ async function backfillAiReferralPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq14(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq15(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -7785,10 +8320,10 @@ async function backfillAiReferralPathsCommand(opts) {
 }
 function backfillProjectAnswerMentions(db, projectId, opts) {
   const isDryRun = opts?.dryRun === true;
-  const project = db.select().from(projects).where(eq14(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq15(projects.id, projectId)).get();
   if (!project) return { examined: 0, updated: 0, mentioned: 0 };
-  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 competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq15(competitors.projectId, projectId)).all().map((row) => row.domain);
+  const runRows = db.select({ id: runs.id }).from(runs).where(and12(eq15(runs.kind, RunKinds["answer-visibility"]), eq15(runs.projectId, projectId))).all();
   const runIds = runRows.map((r) => r.id);
   let examined = 0;
   let updated = 0;
@@ -7862,7 +8397,7 @@ function backfillProjectAnswerMentions(db, projectId, opts) {
       } else {
         db.transaction((tx) => {
           for (const update of pendingUpdates) {
-            tx.update(querySnapshots).set(update.patch).where(eq14(querySnapshots.id, update.id)).run();
+            tx.update(querySnapshots).set(update.patch).where(eq15(querySnapshots.id, update.id)).run();
           }
         });
         updated += pendingUpdates.length;
@@ -7877,7 +8412,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(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -7937,7 +8472,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-G4NV3X36.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-YUUPSJRC.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -8096,7 +8631,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
-  const project = db.select().from(projects).where(eq14(projects.name, opts.project)).get();
+  const project = db.select().from(projects).where(eq15(projects.name, opts.project)).get();
   if (!project) {
     throw new Error(`Project "${opts.project}" not found`);
   }
@@ -8107,8 +8642,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(and11(
-    eq14(auditLog.projectId, project.id),
+  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and12(
+    eq15(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);
@@ -8116,10 +8651,10 @@ async function backfillSnapshotAttributionCommand(opts) {
     runId: runs.id,
     createdAt: runs.createdAt,
     location: runs.location
-  }).from(runs).innerJoin(querySnapshots, eq14(querySnapshots.runId, runs.id)).where(and11(
-    eq14(runs.projectId, project.id),
-    isNull(querySnapshots.queryId),
-    isNull(querySnapshots.queryText)
+  }).from(runs).innerJoin(querySnapshots, eq15(querySnapshots.runId, runs.id)).where(and12(
+    eq15(runs.projectId, project.id),
+    isNull2(querySnapshots.queryId),
+    isNull2(querySnapshots.queryText)
   )).groupBy(runs.id).orderBy(runs.createdAt).all();
   const result = {
     project: project.name,
@@ -8139,10 +8674,10 @@ async function backfillSnapshotAttributionCommand(opts) {
       provider: querySnapshots.provider,
       createdAt: querySnapshots.createdAt,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).where(and11(
-      eq14(querySnapshots.runId, run.runId),
-      isNull(querySnapshots.queryId),
-      isNull(querySnapshots.queryText)
+    }).from(querySnapshots).where(and12(
+      eq15(querySnapshots.runId, run.runId),
+      isNull2(querySnapshots.queryId),
+      isNull2(querySnapshots.queryText)
     )).orderBy(querySnapshots.provider, querySnapshots.createdAt).all();
     const byProvider = /* @__PURE__ */ new Map();
     for (const s of orphanSnaps) {
@@ -8206,7 +8741,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(eq14(querySnapshots.id, u.id)).run();
+        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq15(querySnapshots.id, u.id)).run();
       }
     });
   }
@@ -8280,7 +8815,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(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
   if (scopedProjects.length === 0) {
     if (projectFilter && !isJson) {
       process.stderr.write(`No project named "${projectFilter}".
@@ -8305,8 +8840,8 @@ async function backfillTrafficClassificationCommand(opts) {
     dryRun: isDryRun,
     byBot: {}
   };
-  const unknownCountRow = db.select({ n: sql6`count(*)` }).from(rawEventSamples).where(and11(
-    eq14(rawEventSamples.eventType, "unknown"),
+  const unknownCountRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and12(
+    eq15(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).get();
   result.unknownBefore = Number(unknownCountRow?.n ?? 0);
@@ -8318,8 +8853,8 @@ async function backfillTrafficClassificationCommand(opts) {
     userAgent: rawEventSamples.userAgent,
     pathNormalized: rawEventSamples.pathNormalized,
     status: rawEventSamples.status
-  }).from(rawEventSamples).where(and11(
-    eq14(rawEventSamples.eventType, "unknown"),
+  }).from(rawEventSamples).where(and12(
+    eq15(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).all();
   result.examined = unknownSamples.length;
@@ -8358,7 +8893,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(eq14(rawEventSamples.id, snap.id)).run();
+    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq15(rawEventSamples.id, snap.id)).run();
     const tsHour = new Date(snap.ts);
     tsHour.setUTCMinutes(0, 0, 0);
     if (userFetch) {
@@ -8386,7 +8921,7 @@ async function backfillTrafficClassificationCommand(opts) {
           aiUserFetchEventsHourly.status
         ],
         set: {
-          hits: sql6`${aiUserFetchEventsHourly.hits} + 1`,
+          hits: sql7`${aiUserFetchEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
@@ -8415,15 +8950,15 @@ async function backfillTrafficClassificationCommand(opts) {
           crawlerEventsHourly.status
         ],
         set: {
-          hits: sql6`${crawlerEventsHourly.hits} + 1`,
+          hits: sql7`${crawlerEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
     }
   }
   if (!isDryRun) {
-    const afterRow = db.select({ n: sql6`count(*)` }).from(rawEventSamples).where(and11(
-      eq14(rawEventSamples.eventType, "unknown"),
+    const afterRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and12(
+      eq15(rawEventSamples.eventType, "unknown"),
       inArray4(rawEventSamples.projectId, projectIds)
     )).get();
     result.unknownAfter = Number(afterRow?.n ?? 0);
@@ -8447,8 +8982,8 @@ Traffic classification ${result.dryRun ? "preview" : "recovery"} complete.`);
   if (result.reclassified > 0) {
     console.log(`  By bot:`);
     const sorted = Object.entries(result.byBot).sort(([, a], [, b]) => b - a);
-    for (const [bot, count] of sorted) {
-      console.log(`    ${count.toString().padStart(5)}  ${bot}`);
+    for (const [bot, count2] of sorted) {
+      console.log(`    ${count2.toString().padStart(5)}  ${bot}`);
     }
   }
   if (result.dryRun) {
@@ -8458,7 +8993,7 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 }
 
 // src/commands/skills.ts
-import crypto17 from "crypto";
+import crypto18 from "crypto";
 import fs4 from "fs";
 import os4 from "os";
 import path5 from "path";
@@ -8513,7 +9048,7 @@ function walkRelative(dir, prefix = "") {
   return out.sort();
 }
 function sha256File(filePath) {
-  return crypto17.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
+  return crypto18.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
 }
 function readSkillManifest(skillDir) {
   try {
@@ -8855,9 +9390,9 @@ var ProviderRegistry = class {
 };
 
 // src/scheduler.ts
-import crypto18 from "crypto";
+import crypto19 from "crypto";
 import cron from "node-cron";
-import { and as and12, eq as eq15, inArray as inArray5, notExists, sql as sql7 } from "drizzle-orm";
+import { and as and13, eq as eq16, inArray as inArray5, notExists, sql as sql8 } from "drizzle-orm";
 var log13 = createLogger("Scheduler");
 var DEFAULT_HEALTH_CRON = "0 */6 * * *";
 function taskKey(projectId, kind) {
@@ -8889,16 +9424,16 @@ var Scheduler = class {
    */
   ensureHealthSchedules() {
     const projectsWithoutHealth = this.db.select({ id: projects.id }).from(projects).where(notExists(
-      this.db.select({ one: sql7`1` }).from(schedules).where(and12(
-        eq15(schedules.projectId, projects.id),
-        eq15(schedules.kind, SchedulableRunKinds.doctor)
+      this.db.select({ one: sql8`1` }).from(schedules).where(and13(
+        eq16(schedules.projectId, projects.id),
+        eq16(schedules.kind, SchedulableRunKinds.doctor)
       ))
     )).all();
     if (projectsWithoutHealth.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const project of projectsWithoutHealth) {
       this.db.insert(schedules).values({
-        id: crypto18.randomUUID(),
+        id: crypto19.randomUUID(),
         projectId: project.id,
         kind: SchedulableRunKinds.doctor,
         cronExpr: DEFAULT_HEALTH_CRON,
@@ -8942,7 +9477,7 @@ var Scheduler = class {
   start() {
     this.ensureHealthSchedules();
     this.ensureQueryBaskets();
-    const allSchedules = this.db.select().from(schedules).where(eq15(schedules.enabled, true)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq16(schedules.enabled, true)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
@@ -8972,7 +9507,7 @@ var Scheduler = class {
       this.stopTask(key, existing, "Stopped");
       this.tasks.delete(key);
     }
-    const schedule = this.db.select().from(schedules).where(and12(eq15(schedules.projectId, projectId), eq15(schedules.kind, kind))).get();
+    const schedule = this.db.select().from(schedules).where(and13(eq16(schedules.projectId, projectId), eq16(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -9013,21 +9548,21 @@ var Scheduler = class {
     this.db.update(schedules).set({
       nextRunAt: nextRunFromCron(cronExpr, timezone),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq15(schedules.id, scheduleId)).run();
+    }).where(eq16(schedules.id, scheduleId)).run();
     const label = schedule.preset ?? cronExpr;
     log13.info("cron.registered", { projectId, kind, schedule: label, timezone });
   }
   triggerRun(scheduleId, projectId, kind) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const currentSchedule = this.db.select().from(schedules).where(eq15(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq16(schedules.id, scheduleId)).get();
       if (!currentSchedule || !currentSchedule.enabled) {
         log13.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId, kind);
         return;
       }
       const nextRunAt = nextRunFromCron(currentSchedule.cronExpr, currentSchedule.timezone);
-      const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
       if (!project) {
         log13.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
         this.remove(projectId, kind);
@@ -9047,7 +9582,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("traffic-sync.triggered", { projectName: project.name, sourceId });
         this.callbacks.onTrafficSyncRequested(project.name, sourceId);
         return;
@@ -9057,7 +9592,7 @@ var Scheduler = class {
           log13.warn("gbp-sync.no-callback", { scheduleId, projectId, msg: "host did not register onGbpSyncRequested" });
           return;
         }
-        const runId2 = crypto18.randomUUID();
+        const runId2 = crypto19.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -9070,7 +9605,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onGbpSyncRequested(runId2, projectId);
         return;
@@ -9080,17 +9615,17 @@ var Scheduler = class {
           log13.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(and12(
-          eq15(runs.projectId, projectId),
-          eq15(runs.kind, RunKinds["ads-sync"]),
+        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and13(
+          eq16(runs.projectId, projectId),
+          eq16(runs.kind, RunKinds["ads-sync"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (activeAdsRun) {
           log13.info("ads-sync.skipped-active", { projectName: project.name, activeRunId: activeAdsRun.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq15(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq16(schedules.id, currentSchedule.id)).run();
           return;
         }
-        const runId2 = crypto18.randomUUID();
+        const runId2 = crypto19.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -9103,7 +9638,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onAdsSyncRequested(runId2, projectId);
         return;
@@ -9117,7 +9652,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("data-refresh.triggered", { projectName: project.name });
         this.callbacks.onDataRefreshRequested(project.name);
         return;
@@ -9131,7 +9666,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("doctor.triggered", { projectName: project.name });
         this.callbacks.onDoctorRequested(project.name);
         return;
@@ -9145,7 +9680,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("backlinks-sync.triggered", { projectName: project.name });
         this.callbacks.onBacklinksSyncRequested(project.name);
         return;
@@ -9155,17 +9690,17 @@ var Scheduler = class {
           log13.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(and12(
-          eq15(runs.projectId, projectId),
-          eq15(runs.kind, RunKinds["site-audit"]),
+        const active = this.db.select({ id: runs.id }).from(runs).where(and13(
+          eq16(runs.projectId, projectId),
+          eq16(runs.kind, RunKinds["site-audit"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (active) {
           log13.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq15(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq16(schedules.id, currentSchedule.id)).run();
           return;
         }
-        const runId2 = crypto18.randomUUID();
+        const runId2 = crypto19.randomUUID();
         const effectiveRequest = normalizeSiteAuditRunRequest({});
         this.db.transaction((tx) => {
           tx.insert(runs).values({
@@ -9188,7 +9723,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("site-audit.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onSiteAuditRequested(runId2, projectId);
         return;
@@ -9221,7 +9756,7 @@ var Scheduler = class {
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         return;
       }
       const runId = queueResult.runId;
@@ -9229,7 +9764,7 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq15(schedules.id, currentSchedule.id)).run();
+      }).where(eq16(schedules.id, currentSchedule.id)).run();
       log13.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
       this.callbacks.onRunCreated(runId, projectId, providers, resolvedLocation);
     } catch (err) {
@@ -9262,8 +9797,8 @@ async function refreshAllIntegrations(client, projectName) {
 }
 
 // src/notifier.ts
-import { eq as eq16, desc as desc6, and as and13, inArray as inArray6, or } from "drizzle-orm";
-import crypto19 from "crypto";
+import { eq as eq17, desc as desc7, and as and14, inArray as inArray6, or as or2 } from "drizzle-orm";
+import crypto20 from "crypto";
 var log15 = createLogger("Notifier");
 var Notifier = class {
   db;
@@ -9275,18 +9810,18 @@ var Notifier = class {
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
     log15.info("run.completed", { runId, projectId });
-    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) {
       log15.info("notifications.none-enabled", { projectId });
       return;
     }
     log15.info("notifications.found", { projectId, count: notifs.length });
-    const run = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
     if (!run) {
       log15.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
-    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
@@ -9339,7 +9874,7 @@ var Notifier = class {
    * inferred from the absence of a webhook.
    */
   async onHealthChecked(projectId, report) {
-    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping health notification" });
       return null;
@@ -9370,7 +9905,7 @@ var Notifier = class {
     const status = noSignal ? "warn" : worst ? worst.status : "ok";
     const code = noSignal ? "health.no-signal" : worst?.code ?? "health.ok";
     const summary = noSignal ? `No health check produced a result (${report.checks.length} skipped) \u2014 health is unknown, not confirmed.` : worst?.summary ?? `All ${graded.length} health check(s) passing.`;
-    const previous = this.db.select().from(doctorHealthState).where(eq16(doctorHealthState.projectId, projectId)).get();
+    const previous = this.db.select().from(doctorHealthState).where(eq17(doctorHealthState.projectId, projectId)).get();
     const previousStatus = previous?.status ?? null;
     let event = null;
     if (previous === void 0) {
@@ -9385,13 +9920,13 @@ var Notifier = class {
     if (previous === void 0) {
       this.db.insert(doctorHealthState).values({ ...observation, notifiedAt: null }).run();
     } else {
-      this.db.update(doctorHealthState).set(observation).where(eq16(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set(observation).where(eq17(doctorHealthState.projectId, projectId)).run();
     }
     if (!event) {
       log15.info("health.unchanged", { projectId, status, code });
       return null;
     }
-    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     const payload = {
       source: "canonry",
       event,
@@ -9415,7 +9950,7 @@ var Notifier = class {
       delivered += 1;
     }
     if (delivered > 0) {
-      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq16(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq17(doctorHealthState.projectId, projectId)).run();
     }
     log15.info("health.notified", { projectId, event, status, code, subscribers: notifs.length, delivered });
     return event;
@@ -9428,11 +9963,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(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = notif.config;
@@ -9462,7 +9997,7 @@ var Notifier = class {
     }
   }
   computeTransitions(runId, projectId) {
-    const thisRun = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
+    const thisRun = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
     if (!thisRun) return [];
     const completeness = measurementRunCompleteness(this.db, runId);
     if (completeness.planned && !completeness.complete) {
@@ -9473,10 +10008,10 @@ var Notifier = class {
       });
       return [];
     }
-    const groupSiblings = this.db.select().from(runs).where(and13(
-      eq16(runs.projectId, projectId),
-      eq16(runs.kind, thisRun.kind),
-      eq16(runs.createdAt, thisRun.createdAt)
+    const groupSiblings = this.db.select().from(runs).where(and14(
+      eq17(runs.projectId, projectId),
+      eq17(runs.kind, thisRun.kind),
+      eq17(runs.createdAt, thisRun.createdAt)
     )).all();
     const stillPending = groupSiblings.some((r) => r.status === "queued" || r.status === "running");
     if (stillPending) return [];
@@ -9492,19 +10027,19 @@ 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(eq16(projects.id, projectId)).get();
+    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq17(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(
-      and13(
-        eq16(runs.projectId, projectId),
-        eq16(runs.kind, thisRun.kind),
-        or(eq16(runs.status, "completed"), eq16(runs.status, "partial"))
+      and14(
+        eq17(runs.projectId, projectId),
+        eq17(runs.kind, thisRun.kind),
+        or2(eq17(runs.status, "completed"), eq17(runs.status, "partial"))
       )
-    ).orderBy(desc6(runs.createdAt), desc6(runs.id)).limit(RECENT_FETCH_LIMIT).all();
+    ).orderBy(desc7(runs.createdAt), desc7(runs.id)).limit(RECENT_FETCH_LIMIT).all();
     const groups = groupRunsByCreatedAt(recentRuns);
     const currentGroupIdx = groups.findIndex((g) => g[0]?.createdAt === thisRun.createdAt);
     if (currentGroupIdx < 0) return [];
@@ -9519,7 +10054,7 @@ var Notifier = class {
       provider: querySnapshots.provider,
       location: querySnapshots.location,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(queries, eq16(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
+    }).from(querySnapshots).leftJoin(queries, eq17(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
     const previousSnapshots = this.db.select({
       queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
@@ -9589,7 +10124,7 @@ var Notifier = class {
   }
   logDelivery(projectId, notificationId, event, status, error) {
     this.db.insert(auditLog).values({
-      id: crypto19.randomUUID(),
+      id: crypto20.randomUUID(),
       projectId,
       actor: "scheduler",
       action: `notification.${status}`,
@@ -9602,7 +10137,7 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-import { eq as eq17 } from "drizzle-orm";
+import { eq as eq18 } from "drizzle-orm";
 var log16 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(db, notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
@@ -9618,7 +10153,7 @@ var RunCoordinator = class {
   onInsightsGenerated;
   onAeroEvent;
   async onRunCompleted(runId, projectId) {
-    const runRow = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
+    const runRow = this.db.select().from(runs).where(eq18(runs.id, runId)).get();
     const kind = runRow?.kind ?? RunKinds["answer-visibility"];
     if (runRow?.trigger === RunTriggers.probe) {
       log16.info("probe.skip-side-effects", { runId, projectId, kind });
@@ -9709,7 +10244,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(eq17(discoverySessions.runId, runId)).get();
+    const session = this.db.select().from(discoverySessions).where(eq18(discoverySessions.runId, runId)).get();
     const competitorMap = session ? session.competitorMap : [];
     return {
       kind: RunKinds["aeo-discover-probe"],
@@ -9751,8 +10286,8 @@ function analysisResultFromInsights(insights2) {
 }
 
 // src/agent/session-registry.ts
-import crypto23 from "crypto";
-import { eq as eq19 } from "drizzle-orm";
+import crypto24 from "crypto";
+import { eq as eq20 } from "drizzle-orm";
 
 // src/agent/session.ts
 import fs7 from "fs";
@@ -10495,7 +11030,7 @@ function buildAeroStateTools(ctx, opts = {}) {
 }
 
 // src/agent/llm-usage.ts
-import crypto20 from "crypto";
+import crypto21 from "crypto";
 var AeroLlmUsageFeatures = {
   turn: "aero.turn"
 };
@@ -10514,7 +11049,7 @@ function recordLlmUsageEvent(args) {
     const usage = args.message.usage;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     args.db.insert(llmUsageEvents).values({
-      id: crypto20.randomUUID(),
+      id: crypto21.randomUUID(),
       projectId: args.projectId,
       runId: args.runId,
       agentSessionId: args.agentSessionId,
@@ -10590,7 +11125,7 @@ function splitAeroAnthropicSystemCachePayload(payload, model) {
 }
 
 // src/agent/tool-usage.ts
-import crypto21 from "crypto";
+import crypto22 from "crypto";
 var AeroToolEventStatuses = {
   success: "success",
   error: "error"
@@ -10653,7 +11188,7 @@ function createAeroToolUsageHooks(args) {
 function recordAgentToolEvent(args) {
   try {
     args.db.insert(agentToolEvents).values({
-      id: crypto21.randomUUID(),
+      id: crypto22.randomUUID(),
       projectId: args.projectId,
       agentSessionId: args.agentSessionId,
       toolCallId: args.toolCallId,
@@ -10880,8 +11415,8 @@ async function loadExternalMcpTools(servers, opts = {}) {
 }
 
 // src/agent/memory-store.ts
-import crypto22 from "crypto";
-import { and as and14, desc as desc7, eq as eq18, like, sql as sql8 } from "drizzle-orm";
+import crypto23 from "crypto";
+import { and as and15, desc as desc8, eq as eq19, like, sql as sql9 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -10895,7 +11430,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq18(agentMemory.projectId, projectId)).orderBy(desc7(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq19(agentMemory.projectId, projectId)).orderBy(desc8(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -10909,7 +11444,7 @@ function upsertMemoryEntry(db, args) {
     throw new Error(`memory key prefix "${COMPACTION_KEY_PREFIX}" is reserved for compaction notes`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = crypto22.randomUUID();
+  const id = crypto23.randomUUID();
   db.insert(agentMemory).values({
     id,
     projectId: args.projectId,
@@ -10926,12 +11461,12 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and14(eq18(agentMemory.projectId, args.projectId), eq18(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and15(eq19(agentMemory.projectId, args.projectId), eq19(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(and14(eq18(agentMemory.projectId, projectId), eq18(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and15(eq19(agentMemory.projectId, projectId), eq19(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -10946,7 +11481,7 @@ function writeCompactionNote(db, args) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const key = `${COMPACTION_KEY_PREFIX}${args.sessionId}:${now}`;
-  const id = crypto22.randomUUID();
+  const id = crypto23.randomUUID();
   let inserted;
   db.transaction((tx) => {
     tx.insert(agentMemory).values({
@@ -10960,16 +11495,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(
-      and14(
-        eq18(agentMemory.projectId, args.projectId),
+      and15(
+        eq19(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
-    ).orderBy(desc7(agentMemory.updatedAt)).all();
+    ).orderBy(desc8(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
-      tx.delete(agentMemory).where(sql8`${agentMemory.id} IN (${sql8.join(stale.map((s) => sql8`${s}`), sql8`, `)})`).run();
+      tx.delete(agentMemory).where(sql9`${agentMemory.id} IN (${sql9.join(stale.map((s) => sql9`${s}`), sql9`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and14(eq18(agentMemory.projectId, args.projectId), eq18(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and15(eq19(agentMemory.projectId, args.projectId), eq19(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -11196,7 +11731,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq19(agentSessions.projectId, projectId)).run();
+        }).where(eq20(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -11225,7 +11760,7 @@ var SessionRegistry = class {
     }
     const { provider, modelId } = resolveSessionProviderAndModel(this.opts.config, preferences);
     const systemPrompt = loadAeroSystemPrompt();
-    const sessionId = crypto23.randomUUID();
+    const sessionId = crypto24.randomUUID();
     const agent = createAeroSession({
       projectName,
       client: this.opts.client,
@@ -11430,7 +11965,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq19(agentSessions.projectId, projectId)).run();
+    }).where(eq20(agentSessions.projectId, projectId)).run();
   }
   /** Persist a session's transcript back to the DB. Call after any run settles. */
   save(projectName) {
@@ -11594,17 +12129,17 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq19(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq20(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq19(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq20(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.opts.db.insert(agentSessions).values({
-      id: params.id ?? crypto23.randomUUID(),
+      id: params.id ?? crypto24.randomUUID(),
       projectId: params.projectId,
       systemPrompt: params.systemPrompt,
       modelProvider: params.provider ?? params.modelProvider ?? AgentProviderIds.claude,
@@ -11617,14 +12152,14 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq19(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq20(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/agent-routes.ts
-import { eq as eq20 } from "drizzle-orm";
+import { eq as eq21 } from "drizzle-orm";
 function resolveProject(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq20(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq21(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -11633,7 +12168,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(eq20(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq21(agentSessions.projectId, project.id)).get();
       if (!row) {
         return { messages: [], modelProvider: null, modelId: null, updatedAt: null };
       }
@@ -11657,7 +12192,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(eq20(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -12465,7 +13000,7 @@ function buildSnapshotSummary(companyName, queries2, providers, queryResults, au
       competitorCounts.set(competitor, (competitorCounts.get(competitor) ?? 0) + 1);
     }
   }
-  const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count]) => ({ name, count }));
+  const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count2]) => ({ name, count: count2 }));
   const defaultMeaning = totalComparisons > 0 ? `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider-query response${totalComparisons === 1 ? "" : "s"} across ${queries2.length} category queries.` : `No successful provider responses were returned across ${queries2.length} category queries.`;
   const failureNote = failedComparisons > 0 ? [
     `${failedComparisons} provider response${failedComparisons === 1 ? "" : "s"} failed and ${failedComparisons === 1 ? "was" : "were"} excluded from visibility totals.`
@@ -12600,20 +13135,20 @@ function clipText(value, length) {
 }
 
 // src/research-runner.ts
-import { and as and15, eq as eq21, inArray as inArray7, sql as sql9 } from "drizzle-orm";
+import { and as and16, eq as eq22, inArray as inArray7, sql as sql10 } 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();
+  const run = db.select().from(researchRuns).where(and16(eq22(researchRuns.id, runId), eq22(researchRuns.projectId, projectId))).get();
   if (!run || run.status !== ResearchRunStatuses.queued) return;
-  const project = db.select().from(projects).where(eq21(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq22(projects.id, projectId)).get();
   if (!project) 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();
+  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and16(eq22(researchRuns.id, runId), eq22(researchRuns.status, ResearchRunStatuses.queued))).run();
   if (claim.changes !== 1) return;
   let reserved = 0;
   let dispatched = 0;
@@ -12637,8 +13172,8 @@ async function executeResearchRun(db, registry, runId, projectId) {
     }
     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 rows = db.select().from(researchRunQueries).where(eq22(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
+    const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq22(competitors.projectId, projectId)).all().map((row) => row.domain);
     const domains = effectiveDomains(project);
     const brands = effectiveBrandNames(project);
     const config = { ...provider.config, model: run.resolvedModel };
@@ -12646,7 +13181,7 @@ async function executeResearchRun(db, registry, runId, projectId) {
     await mapWithConcurrency(rows, Math.max(1, provider.config.quotaPolicy.maxConcurrency), async (row) => {
       try {
         const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and15(eq21(researchRunQueries.id, row.id), eq21(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
+        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and16(eq22(researchRunQueries.id, row.id), eq22(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);
@@ -12673,7 +13208,7 @@ async function executeResearchRun(db, registry, runId, projectId) {
           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();
+        }).where(and16(eq22(researchRunQueries.id, row.id), eq22(researchRunQueries.status, ResearchQueryStatuses.running))).run();
         if (completed.changes === 1) incrementResearchProgress(db, runId, "completedQueries");
       } catch (error) {
         try {
@@ -12697,18 +13232,18 @@ async function executeResearchRun(db, registry, runId, projectId) {
   }
 }
 function incrementResearchProgress(db, runId, column) {
-  db.update(researchRuns).set({ [column]: sql9`${researchRuns[column]} + 1` }).where(eq21(researchRuns.id, runId)).run();
+  db.update(researchRuns).set({ [column]: sql10`${researchRuns[column]} + 1` }).where(eq22(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();
+  const failed = db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and16(eq22(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();
+  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and16(eq22(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 rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq22(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({
@@ -12717,11 +13252,11 @@ function finalizeResearchRun(db, runId, fatalError) {
     failedQueries: failed,
     error: fatalError ?? (failed === rows.length ? "Every research query failed." : null),
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq21(researchRuns.id, runId)).run();
+  }).where(eq22(researchRuns.id, runId)).run();
 }
 
 // src/server.ts
-var _require3 = createRequire3(import.meta.url);
+var _require3 = createRequire4(import.meta.url);
 var { version: PKG_VERSION2 } = _require3("../package.json");
 var log20 = createLogger("Server");
 var DEFAULT_QUOTA = {
@@ -12780,14 +13315,14 @@ function summarizeProviderConfig(config) {
   };
 }
 function hashApiKey(key) {
-  return crypto24.createHash("sha256").update(key).digest("hex");
+  return crypto25.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 = crypto24.randomBytes(16);
-  const derived = crypto24.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
+  const salt = crypto25.randomBytes(16);
+  const derived = crypto25.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
     N: DASHBOARD_SCRYPT_COST,
     maxmem: DASHBOARD_SCRYPT_MAXMEM
   });
@@ -12808,14 +13343,14 @@ function verifyDashboardPassword(password, storedHash) {
     } catch {
       return { ok: false, needsRehash: false };
     }
-    const derived = crypto24.scryptSync(password, salt, expected.length, {
+    const derived = crypto25.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: crypto24.timingSafeEqual(derived, expected),
+      ok: crypto25.timingSafeEqual(derived, expected),
       needsRehash: false
     };
   }
@@ -12824,7 +13359,7 @@ function verifyDashboardPassword(password, storedHash) {
     const expected = Buffer.from(storedHash, "hex");
     if (candidate.length !== expected.length)
       return { ok: false, needsRehash: false };
-    const ok = crypto24.timingSafeEqual(candidate, expected);
+    const ok = crypto25.timingSafeEqual(candidate, expected);
     return { ok, needsRehash: ok };
   }
   return { ok: false, needsRehash: false };
@@ -13032,7 +13567,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(eq22(projects.id, ctx.projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq23(projects.id, ctx.projectId)).get();
       if (!project) return;
       let content;
       if (ctx.kind === RunKinds["aeo-discover-probe"]) {
@@ -13382,7 +13917,7 @@ async function createServer(opts) {
       void (async () => {
         try {
           const report = await aeroClient.runDoctor({ project: projectName });
-          const project = opts.db.select().from(projects).where(eq22(projects.name, projectName)).get();
+          const project = opts.db.select().from(projects).where(eq23(projects.name, projectName)).get();
           if (!project) {
             app.log.warn({ projectName }, "doctor schedule fired for an unknown project");
             return;
@@ -13410,9 +13945,9 @@ async function createServer(opts) {
         });
         if (!probed) return;
         const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(
-          and16(
-            eq22(ccReleaseSyncs.release, probed.release),
-            eq22(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
+          and17(
+            eq23(ccReleaseSyncs.release, probed.release),
+            eq23(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
           )
         ).limit(1).get();
         if (alreadySynced) {
@@ -13567,7 +14102,25 @@ async function createServer(opts) {
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto24.randomBytes(32).toString("hex");
+  const cloudflareTrafficCredentialStore = {
+    getConnection: (projectName) => {
+      return getCloudflareTrafficConnection(opts.config, projectName);
+    },
+    getConnectionBySourceId: (sourceId) => {
+      return getCloudflareTrafficConnectionBySourceId(opts.config, sourceId);
+    },
+    upsertConnection: (record) => {
+      const updated = upsertCloudflareTrafficConnection(opts.config, record);
+      saveConfigPatch(opts.config);
+      return updated;
+    },
+    deleteConnection: (projectName) => {
+      const removed = removeCloudflareTrafficConnection(opts.config, projectName);
+      if (removed) saveConfigPatch(opts.config);
+      return removed;
+    }
+  };
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto25.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
@@ -13642,11 +14195,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(eq22(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto24.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto25.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -13670,7 +14223,7 @@ async function createServer(opts) {
   };
   const createSession = (apiKeyId) => {
     pruneExpiredSessions();
-    const sessionId = crypto24.randomBytes(32).toString("hex");
+    const sessionId = crypto25.randomBytes(32).toString("hex");
     sessions.set(sessionId, {
       apiKeyId,
       expiresAt: Date.now() + SESSION_TTL_MS
@@ -13694,7 +14247,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -13718,7 +14271,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(eq22(apiKeys.keyHash, hashApiKey(parts[1]))).get();
+    const key = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(parts[1]))).get();
     return Boolean(key && !key.revokedAt);
   };
   const namedAccountsInUse = () => anyUsersExist(opts.db);
@@ -13808,12 +14361,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq23(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(eq22(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq23(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header(
         "set-cookie",
@@ -14030,7 +14583,7 @@ async function createServer(opts) {
         deps: {
           enqueueAutoExtract: ({ projectId, release: r }) => {
             const now = (/* @__PURE__ */ new Date()).toISOString();
-            const runId = crypto24.randomUUID();
+            const runId = crypto25.randomUUID();
             opts.db.insert(runs).values({
               id: runId,
               projectId,
@@ -14155,7 +14708,7 @@ async function createServer(opts) {
         ...inspectOpts,
         config: opts.config
       }).then(() => {
-        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq22(runs.id, runId)).get();
+        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq23(runs.id, runId)).get();
         if (finished?.status === RunStatuses.completed || finished?.status === RunStatuses.partial) {
           return maybeRefreshGscCoverage(
             opts.db,
@@ -14176,6 +14729,8 @@ async function createServer(opts) {
     cloudRunCredentialStore,
     wordpressTrafficCredentialStore,
     vercelTrafficCredentialStore,
+    cloudflareTrafficCredentialStore,
+    cloudflareTrafficIngestUrl: buildCloudflareIngestUrlTemplate(opts.config),
     onTrafficSynced: (event) => {
       trackEvent(
         "traffic.synced",
@@ -14263,7 +14818,7 @@ async function createServer(opts) {
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         opts.db.insert(auditLog).values(
           targetProjectIds.map((projectId) => ({
-            id: crypto24.randomUUID(),
+            id: crypto25.randomUUID(),
             projectId,
             actor: "api",
             action: existing ? "provider.updated" : "provider.created",
@@ -14401,7 +14956,7 @@ async function createServer(opts) {
         }
       ];
     },
-    onGenerateQueries: async (providerName, count, project) => {
+    onGenerateQueries: async (providerName, count2, project) => {
       const provider = registry.get(providerName);
       if (!provider)
         throw new Error(`Provider "${providerName}" is not configured`);
@@ -14413,10 +14968,10 @@ async function createServer(opts) {
         language: project.language,
         existingQueries: project.existingQueries,
         siteText,
-        count
+        count: count2
       });
       const raw = await provider.adapter.generateText(prompt, provider.config);
-      return parseQueryResponse(raw, count);
+      return parseQueryResponse(raw, count2);
     },
     onSnapshotRequested: async (input) => {
       return snapshotService.createReport(input);
@@ -14531,7 +15086,7 @@ 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()) {
+  for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq23(researchRuns.status, ResearchRunStatuses.queued)).all()) {
     dispatchResearchRun(run.id, run.projectId);
   }
   app.addHook("onClose", async () => {
@@ -14575,7 +15130,7 @@ function buildQueryGenerationPrompt(ctx) {
   );
   return lines.join("\n");
 }
-function parseQueryResponse(raw, count) {
+function parseQueryResponse(raw, count2) {
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const line of raw.split("\n")) {
@@ -14591,7 +15146,7 @@ function parseQueryResponse(raw, count) {
     if (seen.has(key)) continue;
     seen.add(key);
     results.push(cleaned);
-    if (results.length >= count) break;
+    if (results.length >= count2) break;
   }
   return results;
 }
@@ -14614,6 +15169,7 @@ export {
   backfillInsightsCommand,
   backfillSnapshotAttributionCommand,
   backfillTrafficClassificationCommand,
+  getCloudflareTrafficConnection,
   setGoogleAuthConfig,
   installSkills,
   listSkills,