@canonry/canonry 4.157.0 → 4.159.0

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

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-KMTRO56O.js";
+} from "./chunk-ZEG43TY2.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -117,6 +117,7 @@ import {
   researchRunQueries,
   researchRuns,
   resolveDestination,
+  resolveMeasurementSitemapTarget,
   resolveTrustProxy,
   resolveVercelSyncDeadlineMs,
   resolveWebhookTarget,
@@ -136,7 +137,7 @@ import {
   siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-MEBL4EJO.js";
+} from "./chunk-5AFWHKKI.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -169,7 +170,9 @@ import {
   SITE_CRAWL_GRAPH_MAX_NODES,
   SKILL_MANIFEST_FILENAME,
   SchedulableRunKinds,
+  SiteHealthTemplateDetections,
   SkillsClients,
+  TEMPLATE_LINK_RATIO_THRESHOLD,
   TrafficEventConfidences,
   TrafficEventKinds,
   TrafficEvidenceKinds,
@@ -192,8 +195,10 @@ import {
   computeBacklinkSummaryMetrics,
   contentActionLabel,
   contentBriefDtoSchema,
+  createTemplateLinkPairIndex,
   deriveCitedUrlCandidates,
   deriveIndexCoverage,
+  deriveSiteHealthState,
   determineAnswerMentioned,
   dollarsToMicros,
   effectiveBrandNames,
@@ -211,6 +216,8 @@ import {
   isBrowserProvider,
   isGhostTelemetryEvent,
   isRetryableHttpError,
+  isSelfLink,
+  isTemplateLinkRatio,
   isVertexGroundingRedirect,
   mapWithConcurrency,
   normalizeIdTokens,
@@ -219,6 +226,7 @@ import {
   normalizeSiteAuditRunRequest,
   normalizeUrlPath,
   notFound,
+  observeTemplateLinkEdges,
   parseMeasurementRunManifestV1,
   parseOriginList,
   providerError,
@@ -231,12 +239,14 @@ import {
   skillsClientSchema,
   splitList,
   startOfDayHourInTimeZone,
+  templateLinkDetection,
+  templateLinkRatio,
   textContainsBrandAlias,
   textContainsDomain,
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-TRRVBTU5.js";
+} from "./chunk-ZL3VY435.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -571,7 +581,7 @@ import crypto25 from "crypto";
 import fs8 from "fs";
 import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { and as and17, eq as eq23 } from "drizzle-orm";
+import { and as and18, eq as eq24 } from "drizzle-orm";
 import Fastify from "fastify";
 import os5 from "os";
 
@@ -4169,12 +4179,12 @@ var JobRunner = class {
         error: errorMessage
       }).where(eq2(runs.id, runId)).run();
       this.flushProviderUsage(providerDispatchCounts, providerReservations);
-      const abortReason = classifyRunAbortReason(errorMessage);
+      const abortReason2 = classifyRunAbortReason(errorMessage);
       const phases = buildPhases({ startTime, providerCallStart, providerCallEnd });
-      if (abortReason) {
+      if (abortReason2) {
         const domainHash = hashDomain(executionContext.canonicalDomain ?? null);
         trackEvent("run.aborted", {
-          reason: abortReason,
+          reason: abortReason2,
           providerCount: executionContext.providerCount,
           providers: executionContext.providers,
           queryCount: executionContext.queryCount,
@@ -6995,16 +7005,199 @@ function buildDiscoveryInsightTitle(input) {
 
 // src/execute-site-audit.ts
 import crypto17 from "crypto";
-import { and as and11, eq as eq14, sql as sql6 } from "drizzle-orm";
+import { and as and12, eq as eq15, sql as sql6 } from "drizzle-orm";
 import { runSiteCrawl } from "@canonry/aeo-audit";
 
+// src/site-audit-root.ts
+import http from "http";
+import https from "https";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_REDIRECTS = 5;
+var USER_AGENT = "Canonry/1.0 (site-health)";
+async function resolveSiteAuditRootUrl(rawUrl, options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("Site audit root timeout must be positive");
+  const requested = parseHttpUrl2(rawUrl);
+  let current = requested;
+  const redirects = [];
+  const deadlineAt = Date.now() + timeoutMs;
+  const transport = options.transport ?? requestPinnedSiteAuditRoot;
+  for (; ; ) {
+    throwIfAborted(options.signal);
+    const checked = await beforeDeadline(
+      () => options.resolveTarget(current.href),
+      deadlineAt,
+      timeoutMs,
+      options.signal
+    );
+    if (!checked.ok) throw new Error(`Site audit root URL rejected: ${checked.message}`);
+    const checkedUrl = parseHttpUrl2(checked.target.url.href);
+    if (checkedUrl.href !== current.href) {
+      throw new Error("Site audit root target resolver returned a different URL than it validated");
+    }
+    const response = await beforeDeadline(
+      () => transport(checked.target, { timeoutMs: remainingTime(deadlineAt, timeoutMs), signal: options.signal }),
+      deadlineAt,
+      timeoutMs,
+      options.signal
+    );
+    if (!isRedirect(response.status)) {
+      return { requestedUrl: requested.href, effectiveUrl: current.href, redirects };
+    }
+    if (redirects.length >= MAX_REDIRECTS) {
+      throw new Error(`Site audit root has more than ${MAX_REDIRECTS} redirects`);
+    }
+    const location = firstHeader(response.headers.location);
+    if (!location) throw new Error("Site audit root redirect response has no Location header");
+    let next;
+    try {
+      next = parseHttpUrl2(new URL(location, current).href);
+    } catch {
+      throw new Error("Site audit root redirect has an invalid Location header");
+    }
+    assertAllowedRedirect(current, next);
+    redirects.push({ status: response.status, from: current.href, to: next.href });
+    current = next;
+  }
+}
+function parseHttpUrl2(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new Error("Site audit root must be a valid URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Site audit root must use HTTP or HTTPS");
+  }
+  if (url.username || url.password) throw new Error("Site audit root must not include credentials");
+  url.hash = "";
+  return url;
+}
+function canonicalHostAlias(hostname) {
+  return hostname.toLowerCase().replace(/\.$/, "").replace(/^www\./, "");
+}
+function assertAllowedRedirect(current, next) {
+  if (current.protocol === "https:" && next.protocol === "http:") {
+    throw new Error("Site audit root redirect would downgrade HTTPS to HTTP");
+  }
+  if (current.port !== next.port) throw new Error("Site audit root redirect changes port");
+  if (canonicalHostAlias(current.hostname) !== canonicalHostAlias(next.hostname)) {
+    throw new Error("Site audit root redirect points outside the approved site");
+  }
+}
+function isRedirect(status) {
+  return status >= 300 && status < 400;
+}
+function firstHeader(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function remainingTime(deadlineAt, timeoutMs) {
+  const remaining = deadlineAt - Date.now();
+  if (remaining <= 0) throw new Error(`Site audit root resolution exceeded its ${timeoutMs}ms deadline`);
+  return remaining;
+}
+async function beforeDeadline(operation, deadlineAt, timeoutMs, signal) {
+  throwIfAborted(signal);
+  const remaining = remainingTime(deadlineAt, timeoutMs);
+  let timer;
+  let abortListener;
+  try {
+    const value = await Promise.race([
+      operation(),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`Site audit root resolution exceeded its ${timeoutMs}ms deadline`)),
+          remaining
+        );
+      }),
+      new Promise((_resolve, reject) => {
+        if (!signal) return;
+        abortListener = () => reject(abortReason(signal));
+        signal.addEventListener("abort", abortListener, { once: true });
+        if (signal.aborted) abortListener();
+      })
+    ]);
+    remainingTime(deadlineAt, timeoutMs);
+    return value;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (abortListener) signal?.removeEventListener("abort", abortListener);
+  }
+}
+function abortReason(signal) {
+  return signal.reason instanceof Error ? signal.reason : new DOMException("Operation aborted", "AbortError");
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortReason(signal);
+}
+function stripIpv6Brackets(hostname) {
+  return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+function buildSiteAuditRootRequestOptions(target) {
+  const secure = target.url.protocol === "https:";
+  const requestOptions = {
+    hostname: target.address,
+    family: target.family,
+    port: target.url.port ? Number(target.url.port) : secure ? 443 : 80,
+    method: "GET",
+    path: `${target.url.pathname}${target.url.search}`,
+    headers: {
+      Host: target.url.host,
+      Accept: "text/html,*/*;q=0.1",
+      "User-Agent": USER_AGENT
+    }
+  };
+  if (secure) requestOptions.servername = stripIpv6Brackets(target.url.hostname);
+  return requestOptions;
+}
+async function requestPinnedSiteAuditRoot(target, options) {
+  throwIfAborted(options.signal);
+  const secure = target.url.protocol === "https:";
+  const requestOptions = buildSiteAuditRootRequestOptions(target);
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let abortListener;
+    const cleanup = () => {
+      clearTimeout(timer);
+      if (abortListener) options.signal?.removeEventListener("abort", abortListener);
+    };
+    const succeed = (response) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(response);
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const request = (secure ? https.request : http.request)(requestOptions, (response) => {
+      response.destroy();
+      succeed({ status: response.statusCode ?? 0, headers: response.headers });
+    });
+    const timer = setTimeout(
+      () => request.destroy(new Error(`Site audit root request timed out after ${options.timeoutMs}ms`)),
+      options.timeoutMs
+    );
+    if (options.signal) {
+      abortListener = () => request.destroy(abortReason(options.signal));
+      options.signal.addEventListener("abort", abortListener, { once: true });
+      if (options.signal.aborted) abortListener();
+    }
+    request.on("error", fail);
+    request.end();
+  });
+}
+
 // 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");
@@ -7014,20 +7207,88 @@ var FORCE_ATLAS_SETTINGS = Object.freeze({
   barnesHutOptimize: true,
   barnesHutTheta: 0.5,
   edgeWeightInfluence: 0.5,
-  gravity: 1,
-  linLogMode: false,
-  outboundAttractionDistribution: false,
-  scalingRatio: 10,
+  gravity: 0.2,
+  linLogMode: true,
+  outboundAttractionDistribution: true,
+  scalingRatio: 2,
   slowDown: 10,
   strongGravityMode: false
 });
+var RENDER_MAX_NODE_SIZE = 14;
+var RENDER_HALF_EXTENT_PX = 420;
+var NODE_SIZE_EXTENT_FRACTION = RENDER_MAX_NODE_SIZE / RENDER_HALF_EXTENT_PX;
+function siteCrawlGraphNodeSize(extent, nodeCount) {
+  if (!Number.isFinite(extent) || extent <= 0 || nodeCount <= 0) return 0;
+  const byExtent = extent * NODE_SIZE_EXTENT_FRACTION;
+  const byArea = Math.sqrt(NOVERLAP_SETTINGS.maxPackingFraction * (2 * extent) ** 2 / nodeCount) / 2;
+  return Math.min(byExtent, byArea);
+}
+function siteCrawlGraphExtent(positions) {
+  if (positions.length === 0) return 0;
+  const centerX = positions.reduce((sum, p) => sum + p.x, 0) / positions.length;
+  const centerY = positions.reduce((sum, p) => sum + p.y, 0) / positions.length;
+  let extent = 0;
+  for (const position of positions) {
+    extent = Math.max(extent, Math.abs(position.x - centerX), Math.abs(position.y - centerY));
+  }
+  return extent;
+}
+var NOVERLAP_SETTINGS = Object.freeze({
+  /** Half a node of clear space between two touching nodes. */
+  marginFactor: 0.5,
+  expansion: 1.1,
+  ratio: 1,
+  speed: 3,
+  /**
+   * Node discs may claim at most this share of the graph's bounding box. At
+   * the 20k cap the extent-derived size asks for spacing the graph physically
+   * does not have, and noverlap either runs for minutes or overflows its
+   * collision set. This bound keeps the pass solvable at every graph size,
+   * and it only binds on graphs far too dense to read node-by-node anyway.
+   */
+  maxPackingFraction: 0.15,
+  /** Cells hold a handful of nodes each, which is what keeps the pass linear. */
+  gridSizeMin: 10,
+  gridSizeMax: 200,
+  iterationLadder: [
+    { maxNodes: 1e3, iterations: 120 },
+    { maxNodes: 5e3, iterations: 60 }
+  ],
+  iterationsFloor: 20
+});
+function noverlapGridSize(nodeCount) {
+  return Math.max(
+    NOVERLAP_SETTINGS.gridSizeMin,
+    Math.min(NOVERLAP_SETTINGS.gridSizeMax, Math.ceil(Math.sqrt(Math.max(1, nodeCount))))
+  );
+}
+function noverlapMaxIterations(nodeCount) {
+  for (const step of NOVERLAP_SETTINGS.iterationLadder) {
+    if (nodeCount <= step.maxNodes) return step.iterations;
+  }
+  return NOVERLAP_SETTINGS.iterationsFloor;
+}
+var COMPONENT_PACKING_SPACING_FACTOR = 3;
+function siteCrawlGraphLayoutSettingsFingerprint(settings) {
+  return crypto16.createHash("sha256").update(JSON.stringify(settings)).digest("hex").slice(0, 8);
+}
+var SITE_CRAWL_GRAPH_LAYOUT_ALGORITHM = "site-health-fa2-v4";
+var SITE_CRAWL_GRAPH_LAYOUT_VERSION = `${SITE_CRAWL_GRAPH_LAYOUT_ALGORITHM}-${siteCrawlGraphLayoutSettingsFingerprint({
+  forceAtlas: FORCE_ATLAS_SETTINGS,
+  noverlap: NOVERLAP_SETTINGS,
+  nodeSizeExtentFraction: NODE_SIZE_EXTENT_FRACTION,
+  componentPackingSpacingFactor: COMPONENT_PACKING_SPACING_FACTOR,
+  templateLinkRatioThreshold: TEMPLATE_LINK_RATIO_THRESHOLD
+})}`;
 var WORKER_SOURCE = String.raw`
 const {parentPort, workerData} = require('node:worker_threads');
 try {
   const graphologyModule = require(workerData.graphologyPath);
   const forceAtlasModule = require(workerData.forceAtlasPath);
+  const noverlapModule = require(workerData.noverlapPath);
   const MultiDirectedGraph = graphologyModule.MultiDirectedGraph;
   const forceAtlas2 = forceAtlasModule.default || forceAtlasModule;
+  const noverlap = noverlapModule.default || noverlapModule;
   const graph = new MultiDirectedGraph({allowSelfLoops: true});
   for (const node of workerData.input.nodes) {
     graph.addNode(node.nodeKey, {x: node.x, y: node.y});
@@ -7043,11 +7304,52 @@ try {
       settings: workerData.settings,
     });
   }
+  let nodeSize = 0;
+  // Anti-overlap runs on the spatialization ForceAtlas2 just produced. Node
+  // size is uniform and derived from the graph's own extent, so the pass is
+  // scale invariant and stays deterministic for a fixed input.
+  if (graph.order > 1) {
+    let sumX = 0;
+    let sumY = 0;
+    graph.forEachNode(function (nodeKey, attributes) {
+      sumX += attributes.x;
+      sumY += attributes.y;
+    });
+    const centerX = sumX / graph.order;
+    const centerY = sumY / graph.order;
+    let extent = 0;
+    graph.forEachNode(function (nodeKey, attributes) {
+      extent = Math.max(extent, Math.abs(attributes.x - centerX), Math.abs(attributes.y - centerY));
+    });
+    if (Number.isFinite(extent) && extent > 0) {
+      // Whichever bound is tighter: one render-sized node, or the largest disc
+      // that still leaves the graph mostly empty space at this node count.
+      // Mirrors siteCrawlGraphNodeSize; a test asserts the two agree.
+      const byExtent = extent * workerData.nodeSizeExtentFraction;
+      const byArea = Math.sqrt(
+        (workerData.noverlap.maxPackingFraction * Math.pow(2 * extent, 2)) / graph.order,
+      ) / 2;
+      nodeSize = Math.min(byExtent, byArea);
+      graph.forEachNode(function (nodeKey) {
+        graph.setNodeAttribute(nodeKey, 'size', nodeSize);
+      });
+      noverlap.assign(graph, {
+        maxIterations: workerData.noverlap.maxIterations,
+        settings: {
+          gridSize: workerData.noverlap.gridSize,
+          margin: nodeSize * workerData.noverlap.marginFactor,
+          expansion: workerData.noverlap.expansion,
+          ratio: workerData.noverlap.ratio,
+          speed: workerData.noverlap.speed,
+        },
+      });
+    }
+  }
   const positions = [];
   graph.forEachNode((nodeKey, attributes) => {
     positions.push({nodeKey, x: attributes.x, y: attributes.y});
   });
-  parentPort.postMessage({ok: true, positions});
+  parentPort.postMessage({ok: true, positions, nodeSize});
 } catch (error) {
   parentPort.postMessage({
     ok: false,
@@ -7105,7 +7407,8 @@ function adaptiveForceAtlasIterations(nodeCount, edgeCount) {
 }
 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 positions = input.nodes.map(({ nodeKey, x, y }) => ({ nodeKey, x, y }));
+    return { positions, nodeSize: siteCrawlGraphNodeSize(siteCrawlGraphExtent(positions), positions.length) };
   }
   const requireFromPackage = createRequire3(import.meta.url);
   const worker = new Worker(WORKER_SOURCE, {
@@ -7113,8 +7416,15 @@ async function computeForceAtlasPositions(input, options = {}) {
     workerData: {
       graphologyPath: requireFromPackage.resolve("graphology"),
       forceAtlasPath: requireFromPackage.resolve("graphology-layout-forceatlas2"),
+      noverlapPath: requireFromPackage.resolve("graphology-layout-noverlap"),
       input,
-      settings: FORCE_ATLAS_SETTINGS
+      settings: FORCE_ATLAS_SETTINGS,
+      noverlap: {
+        ...NOVERLAP_SETTINGS,
+        gridSize: noverlapGridSize(input.nodes.length),
+        maxIterations: noverlapMaxIterations(input.nodes.length)
+      },
+      nodeSizeExtentFraction: NODE_SIZE_EXTENT_FRACTION
     }
   });
   const timeoutMs = options.timeoutMs ?? SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS;
@@ -7127,7 +7437,7 @@ async function computeForceAtlasPositions(input, options = {}) {
       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 ?? []);
+      else resolve({ positions: result.positions ?? [], nodeSize: result.nodeSize ?? 0 });
     };
     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);
@@ -7135,7 +7445,7 @@ async function computeForceAtlasPositions(input, options = {}) {
     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 });
+      else finish({ positions: message.positions, nodeSize: message.nodeSize });
     });
     worker.once("error", (error) => finish({ error }));
     worker.once("exit", (code) => {
@@ -7143,6 +7453,89 @@ async function computeForceAtlasPositions(input, options = {}) {
     });
   });
 }
+function siteCrawlGraphComponents(nodeKeys, edges) {
+  const parent = new Map(nodeKeys.map((key) => [key, key]));
+  const find = (key) => {
+    let root = key;
+    while (parent.get(root) !== root) root = parent.get(root);
+    let cursor = key;
+    while (parent.get(cursor) !== root) {
+      const next = parent.get(cursor);
+      parent.set(cursor, root);
+      cursor = next;
+    }
+    return root;
+  };
+  for (const edge of edges) {
+    if (!parent.has(edge.sourceNodeKey) || !parent.has(edge.targetNodeKey)) continue;
+    const sourceRoot = find(edge.sourceNodeKey);
+    const targetRoot = find(edge.targetNodeKey);
+    if (sourceRoot === targetRoot) continue;
+    if (sourceRoot < targetRoot) parent.set(targetRoot, sourceRoot);
+    else parent.set(sourceRoot, targetRoot);
+  }
+  const members = /* @__PURE__ */ new Map();
+  for (const key of [...nodeKeys].sort()) {
+    const root = find(key);
+    const group = members.get(root);
+    if (group) group.push(key);
+    else members.set(root, [key]);
+  }
+  return [...members.values()].sort((left, right) => right.length - left.length || (left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0));
+}
+function describeComponent(nodeKeys, byKey) {
+  let sumX = 0;
+  let sumY = 0;
+  for (const nodeKey of nodeKeys) {
+    const position = byKey.get(nodeKey);
+    sumX += position.x;
+    sumY += position.y;
+  }
+  const centerX = sumX / nodeKeys.length;
+  const centerY = sumY / nodeKeys.length;
+  let radius = 0;
+  for (const nodeKey of nodeKeys) {
+    const position = byKey.get(nodeKey);
+    radius = Math.max(radius, Math.hypot(position.x - centerX, position.y - centerY));
+  }
+  return { nodeKeys, centerX, centerY, radius };
+}
+function packSiteCrawlGraphComponents(positions, edges, nodeSpacing) {
+  const components = siteCrawlGraphComponents(positions.map((position) => position.nodeKey), edges);
+  if (components.length <= 1) return [...positions];
+  const byKey = new Map(positions.map((position) => [position.nodeKey, position]));
+  if (positions.some((position) => !Number.isFinite(position.x) || !Number.isFinite(position.y))) {
+    return [...positions];
+  }
+  const described = components.map((nodeKeys) => describeComponent(nodeKeys, byKey));
+  const [anchor, ...rest] = described;
+  const spacing = Math.max(nodeSpacing, Number.EPSILON) * COMPONENT_PACKING_SPACING_FACTOR;
+  const ordered = [...rest].sort((left, right) => right.radius - left.radius || (left.nodeKeys[0] < right.nodeKeys[0] ? -1 : left.nodeKeys[0] > right.nodeKeys[0] ? 1 : 0));
+  const moved = /* @__PURE__ */ new Map();
+  let ringRadius = anchor.radius + spacing;
+  let ringPitch = 0;
+  let placedOnRing = 0;
+  let ringCapacity = 0;
+  for (const component of ordered) {
+    if (placedOnRing >= ringCapacity) {
+      ringPitch = 2 * component.radius + spacing;
+      ringRadius += ringPitch / 2 + (placedOnRing === 0 ? 0 : ringPitch / 2);
+      ringCapacity = Math.max(1, Math.floor(2 * Math.PI * ringRadius / ringPitch));
+      placedOnRing = 0;
+    }
+    const angle = placedOnRing / ringCapacity * Math.PI * 2;
+    placedOnRing += 1;
+    const targetX = anchor.centerX + Math.cos(angle) * ringRadius;
+    const targetY = anchor.centerY + Math.sin(angle) * ringRadius;
+    const shiftX = targetX - component.centerX;
+    const shiftY = targetY - component.centerY;
+    for (const nodeKey of component.nodeKeys) {
+      const position = byKey.get(nodeKey);
+      moved.set(nodeKey, { nodeKey, x: position.x + shiftX, y: position.y + shiftY });
+    }
+  }
+  return positions.map((position) => moved.get(position.nodeKey) ?? position);
+}
 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");
@@ -7175,29 +7568,41 @@ async function layoutSiteCrawlGraphInput(input, options = {}) {
       failureCode: "empty-crawl",
       totalNodes: input.totalNodes,
       totalEdges: input.totalEdges,
+      totalTemplateEdges: input.totalTemplateEdges,
       nodeCount: 0,
       edgeCount: 0,
       nodes: [],
       edges: []
     };
   }
+  const layoutEdges = input.edges.filter((edge) => !edge.isTemplate);
   const seeded = seedSiteCrawlGraphNodes(input.nodes, input.rootNodeKey, input.priorPositions);
+  const timeoutMs = options.timeoutMs ?? SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  const assertWithinBudget = () => {
+    options.signal?.throwIfAborted();
+    if (Date.now() > deadline) throw new GraphLayoutTimeoutError(`Graph layout exceeded ${timeoutMs}ms`);
+  };
   try {
     const compute = options.computePositions ?? computeForceAtlasPositions;
-    const positions = await compute({
+    const { positions, nodeSize } = await compute({
       nodes: seeded,
-      edges: input.edges,
-      iterations: adaptiveForceAtlasIterations(input.nodes.length, input.edges.length)
-    }, { signal: options.signal, timeoutMs: options.timeoutMs });
-    options.signal?.throwIfAborted();
+      edges: layoutEdges,
+      iterations: adaptiveForceAtlasIterations(input.nodes.length, layoutEdges.length)
+    }, { signal: options.signal, timeoutMs: Math.max(1, deadline - Date.now()) });
+    assertWithinBudget();
+    const framed = packSiteCrawlGraphComponents(positions, layoutEdges, nodeSize);
+    assertWithinBudget();
     return {
       state: "ready",
       layoutVersion: SITE_CRAWL_GRAPH_LAYOUT_VERSION,
       totalNodes: input.totalNodes,
       totalEdges: input.totalEdges,
+      totalTemplateEdges: input.totalTemplateEdges,
       nodeCount: input.nodes.length,
       edgeCount: input.edges.length,
-      nodes: normalizePositions(seeded, positions, input.rootNodeKey),
+      templateLinksExcluded: true,
+      nodes: normalizePositions(seeded, framed, input.rootNodeKey),
       edges: input.edges.map((edge, sampleRank) => ({ ...edge, sampleRank }))
     };
   } catch (error) {
@@ -7208,6 +7613,7 @@ async function layoutSiteCrawlGraphInput(input, options = {}) {
       failureCode: error instanceof GraphLayoutTimeoutError ? "layout-timeout" : "layout-error",
       totalNodes: input.totalNodes,
       totalEdges: input.totalEdges,
+      totalTemplateEdges: input.totalTemplateEdges,
       nodeCount: 0,
       edgeCount: 0,
       nodes: [],
@@ -7244,6 +7650,7 @@ function loadPriorSiteCrawlGraphPositions(db, scope) {
 async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
   let totalNodes = 0;
   let totalEdges = 0;
+  let totalTemplateEdges = 0;
   try {
     const assertNotAborted = () => options.signal?.throwIfAborted();
     assertNotAborted();
@@ -7261,7 +7668,7 @@ async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
     ];
     totalNodes = db.select({ value: count() }).from(siteCrawlPages).where(and10(...pageScope)).get()?.value ?? 0;
     assertNotAborted();
-    totalEdges = db.select({ value: count() }).from(siteCrawlEdges).innerJoin(graphSourcePage, and10(
+    const countGraphCompatibleEdges = (...extra) => db.select({ value: count() }).from(siteCrawlEdges).innerJoin(graphSourcePage, and10(
       eq13(graphSourcePage.projectId, scope.projectId),
       eq13(graphSourcePage.runId, scope.runId),
       eq13(graphSourcePage.attemptId, scope.attemptId),
@@ -7271,7 +7678,10 @@ async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
       eq13(graphTargetPage.runId, scope.runId),
       eq13(graphTargetPage.attemptId, scope.attemptId),
       eq13(graphTargetPage.nodeKey, siteCrawlEdges.targetNodeKey)
-    )).where(and10(...edgeScope)).get()?.value ?? 0;
+    )).where(and10(...edgeScope, ...extra)).get()?.value ?? 0;
+    totalEdges = countGraphCompatibleEdges();
+    assertNotAborted();
+    totalTemplateEdges = countGraphCompatibleEdges(eq13(siteCrawlEdges.isTemplate, true));
     assertNotAborted();
     const graphSeedColumns = {
       nodeKey: siteCrawlPages.nodeKey,
@@ -7310,7 +7720,8 @@ async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
         edge.source_node_key AS sourceNodeKey,
         edge.target_node_key AS targetNodeKey,
         edge.followable AS followable,
-        edge.occurrences AS occurrences
+        edge.occurrences AS occurrences,
+        edge.is_template AS isTemplate
       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
@@ -7326,8 +7737,9 @@ async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
     return await layoutSiteCrawlGraphInput({
       totalNodes,
       totalEdges,
+      totalTemplateEdges,
       nodes,
-      edges: edgeRows,
+      edges: edgeRows.map((row) => ({ ...row, isTemplate: Boolean(row.isTemplate) })),
       rootNodeKey,
       priorPositions
     }, options);
@@ -7339,6 +7751,7 @@ async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
       failureCode: "layout-error",
       totalNodes,
       totalEdges,
+      totalTemplateEdges,
       nodeCount: 0,
       edgeCount: 0,
       nodes: [],
@@ -7363,8 +7776,10 @@ function persistSiteCrawlGraphLayout(db, scope, layout, now = (/* @__PURE__ */ n
       failureCode: layout.state === "unavailable" ? layout.failureCode : null,
       totalNodes: layout.totalNodes,
       totalEdges: layout.totalEdges,
+      totalTemplateEdges: layout.totalTemplateEdges,
       nodeCount: layout.nodeCount,
       edgeCount: layout.edgeCount,
+      templateLinksExcluded: layout.state === "ready",
       createdAt: now,
       updatedAt: now
     }).run();
@@ -7395,6 +7810,7 @@ function persistSiteCrawlGraphLayout(db, scope, layout, now = (/* @__PURE__ */ n
         targetNodeKey: edge.targetNodeKey,
         followable: edge.followable,
         occurrences: edge.occurrences,
+        isTemplate: edge.isTemplate,
         createdAt: now
       }))).run();
     }
@@ -7408,6 +7824,70 @@ function deleteSiteCrawlGraphLayout(db, scope) {
   )).run();
 }
 
+// src/site-crawl-template-links.ts
+import { and as and11, asc as asc2, eq as eq14, gt, inArray as inArray4 } from "drizzle-orm";
+var TEMPLATE_LINK_READ_BATCH = 2e3;
+var TEMPLATE_LINK_WRITE_BATCH = 500;
+function* streamAttemptEdges(db, scope) {
+  let after = "";
+  for (; ; ) {
+    const rows = db.select({
+      edgeKey: siteCrawlEdges.edgeKey,
+      sourceNodeKey: siteCrawlEdges.sourceNodeKey,
+      targetNodeKey: siteCrawlEdges.targetNodeKey,
+      anchors: siteCrawlEdges.anchors
+    }).from(siteCrawlEdges).where(and11(
+      eq14(siteCrawlEdges.projectId, scope.projectId),
+      eq14(siteCrawlEdges.runId, scope.runId),
+      eq14(siteCrawlEdges.attemptId, scope.attemptId),
+      gt(siteCrawlEdges.edgeKey, after)
+    )).orderBy(asc2(siteCrawlEdges.edgeKey)).limit(TEMPLATE_LINK_READ_BATCH).all();
+    if (rows.length === 0) return;
+    yield rows;
+    after = rows[rows.length - 1].edgeKey;
+    if (rows.length < TEMPLATE_LINK_READ_BATCH) return;
+  }
+}
+function* chunked(values, size = TEMPLATE_LINK_WRITE_BATCH) {
+  for (let offset = 0; offset < values.length; offset += size) {
+    yield values.slice(offset, offset + size);
+  }
+}
+function classifySiteCrawlTemplateLinks(db, scope, pagesFetched) {
+  const scopeFilter = and11(
+    eq14(siteCrawlEdges.projectId, scope.projectId),
+    eq14(siteCrawlEdges.runId, scope.runId),
+    eq14(siteCrawlEdges.attemptId, scope.attemptId)
+  );
+  const detection = templateLinkDetection(pagesFetched);
+  db.update(siteCrawlEdges).set({ isTemplate: false, templateRatio: null }).where(scopeFilter).run();
+  if (detection !== SiteHealthTemplateDetections.applied) {
+    return { detection, templateEdgeCount: 0 };
+  }
+  const index = createTemplateLinkPairIndex();
+  for (const batch of streamAttemptEdges(db, scope)) observeTemplateLinkEdges(index, batch);
+  const edgeKeysByRatio = /* @__PURE__ */ new Map();
+  let templateEdgeCount = 0;
+  for (const batch of streamAttemptEdges(db, scope)) {
+    for (const edge of batch) {
+      const ratio = templateLinkRatio(index, pagesFetched, edge);
+      if (ratio == null) continue;
+      const group = edgeKeysByRatio.get(ratio);
+      if (group) group.push(edge.edgeKey);
+      else edgeKeysByRatio.set(ratio, [edge.edgeKey]);
+      if (isTemplateLinkRatio(ratio)) templateEdgeCount += 1;
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const [ratio, edgeKeys] of edgeKeysByRatio) {
+    const isTemplate = isTemplateLinkRatio(ratio);
+    for (const chunk of chunked(edgeKeys)) {
+      db.update(siteCrawlEdges).set({ isTemplate, templateRatio: ratio, updatedAt: now }).where(and11(scopeFilter, inArray4(siteCrawlEdges.edgeKey, chunk))).run();
+    }
+  }
+  return { detection, templateEdgeCount };
+}
+
 // src/execute-site-audit.ts
 var log12 = createLogger("SiteAudit");
 var SiteAuditCancelledError = class extends Error {
@@ -7555,9 +8035,9 @@ 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(and11(eq14(runs.id, runId), eq14(runs.projectId, projectId), eq14(runs.status, "queued"))).run();
+  const claim = db.update(runs).set({ status: "running", startedAt }).where(and12(eq15(runs.id, runId), eq15(runs.projectId, projectId), eq15(runs.status, "queued"))).run();
   if (claim.changes === 0) return;
-  const attemptNumber = (db.select({ value: sql6`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq14(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
+  const attemptNumber = (db.select({ value: sql6`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq15(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
   const attemptId = crypto17.randomUUID();
   db.insert(siteCrawlAttempts).values({
     id: attemptId,
@@ -7592,28 +8072,49 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       const nodeKey = nodeKeyByUrl.get(url);
       if (!nodeKey) continue;
       const scope = [
-        eq14(siteCrawlEdges.projectId, projectId),
-        eq14(siteCrawlEdges.runId, runId),
-        eq14(siteCrawlEdges.attemptId, attemptId)
+        eq15(siteCrawlEdges.projectId, projectId),
+        eq15(siteCrawlEdges.runId, runId),
+        eq15(siteCrawlEdges.attemptId, attemptId)
       ];
-      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and11(
+      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and12(
         ...scope,
-        eq14(siteCrawlEdges.sourceUrl, url)
+        eq15(siteCrawlEdges.sourceUrl, url)
       )).run();
-      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and11(
+      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and12(
         ...scope,
-        eq14(siteCrawlEdges.targetUrl, url)
-      )).run();
-      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)
+        eq15(siteCrawlEdges.targetUrl, url)
       )).run();
+      const pageScope = [
+        eq15(siteCrawlPages.projectId, projectId),
+        eq15(siteCrawlPages.runId, runId),
+        eq15(siteCrawlPages.attemptId, attemptId)
+      ];
+      const canonicalTargets = tx.select({
+        id: siteCrawlPages.id,
+        nodeKey: siteCrawlPages.nodeKey,
+        fetchState: siteCrawlPages.fetchState,
+        indexabilityState: siteCrawlPages.indexabilityState,
+        indexabilityReasons: siteCrawlPages.indexabilityReasons
+      }).from(siteCrawlPages).where(and12(...pageScope, eq15(siteCrawlPages.canonicalUrl, url))).all();
+      for (const target of canonicalTargets) {
+        tx.update(siteCrawlPages).set({
+          canonicalNodeKey: nodeKey,
+          healthState: deriveSiteHealthState({ ...target, canonicalNodeKey: nodeKey }),
+          updatedAt: now
+        }).where(eq15(siteCrawlPages.id, target.id)).run();
+      }
     }
   };
   const persistPage = (tx, page, now) => {
     const audit = page.audit;
+    const canonicalNodeKey = page.canonicalUrl ? nodeKeyByUrl.get(page.canonicalUrl) ?? null : null;
+    const healthState = deriveSiteHealthState({
+      fetchState: page.state,
+      indexabilityState: page.indexability.state,
+      indexabilityReasons: page.indexability.reasons,
+      canonicalNodeKey,
+      nodeKey: page.key
+    });
     tx.insert(siteCrawlPages).values({
       id: crypto17.randomUUID(),
       projectId,
@@ -7638,9 +8139,10 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       redirectChain: page.redirectChain.map((hop) => hop.to),
       directives: { metaRobots: page.metaRobots, xRobots: page.xRobots },
       canonicalUrl: page.canonicalUrl,
-      canonicalNodeKey: page.canonicalUrl ? nodeKeyByUrl.get(page.canonicalUrl) ?? null : null,
+      canonicalNodeKey,
       indexabilityState: page.indexability.state,
       indexabilityReasons: page.indexability.reasons,
+      healthState,
       auditState: pageAuditState(page),
       auditScore: audit?.overallScore ?? null,
       auditFields: audit ? crawlAuditFields(audit) : {},
@@ -7671,9 +8173,10 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         redirectChain: page.redirectChain.map((hop) => hop.to),
         directives: { metaRobots: page.metaRobots, xRobots: page.xRobots },
         canonicalUrl: page.canonicalUrl,
-        canonicalNodeKey: page.canonicalUrl ? nodeKeyByUrl.get(page.canonicalUrl) ?? null : null,
+        canonicalNodeKey,
         indexabilityState: page.indexability.state,
         indexabilityReasons: page.indexability.reasons,
+        healthState,
         auditState: pageAuditState(page),
         auditScore: audit?.overallScore ?? null,
         auditFields: audit ? crawlAuditFields(audit) : {},
@@ -7696,6 +8199,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     bindReferences(tx, changedUrls, now);
   };
   const persistEdge = (tx, edge, now) => {
+    if (isSelfLink(edge.from, edge.to)) return;
     observedEdges.set(edge.key, edge);
     tx.insert(siteCrawlEdges).values({
       id: crypto17.randomUUID(),
@@ -7744,20 +8248,20 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       linkScoreRaw: metrics.linkScoreRaw,
       linkScoreNormalized: metrics.linkScore,
       updatedAt: now
-    }).where(and11(
-      eq14(siteCrawlPages.projectId, projectId),
-      eq14(siteCrawlPages.runId, runId),
-      eq14(siteCrawlPages.attemptId, attemptId),
-      eq14(siteCrawlPages.nodeKey, key)
+    }).where(and12(
+      eq15(siteCrawlPages.projectId, projectId),
+      eq15(siteCrawlPages.runId, runId),
+      eq15(siteCrawlPages.attemptId, attemptId),
+      eq15(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(and11(
-        eq14(siteCrawlEventReceipts.attemptId, attemptId),
-        eq14(siteCrawlEventReceipts.sequence, event.sequence),
-        eq14(siteCrawlEventReceipts.batchId, event.batchId)
+      const receipt = tx.select({ checksum: siteCrawlEventReceipts.checksum }).from(siteCrawlEventReceipts).where(and12(
+        eq15(siteCrawlEventReceipts.attemptId, attemptId),
+        eq15(siteCrawlEventReceipts.sequence, event.sequence),
+        eq15(siteCrawlEventReceipts.batchId, event.batchId)
       )).get();
       if (receipt) {
         if (receipt.checksum !== event.checksum) {
@@ -7790,26 +8294,39 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           pagesErrored: event.type === "summary" ? observedErrorCount(observedPages.values()) : sql6`${siteCrawlAttempts.pagesErrored}`,
           edgesDiscovered: progress.edgesObserved,
           updatedAt: now
-        }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
+        }).where(eq15(siteCrawlAttempts.id, attemptId)).run();
       } else {
         tx.update(siteCrawlAttempts).set({
           lastEventSequence: event.sequence,
           lastEventChecksum: event.checksum,
           updatedAt: now
-        }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
+        }).where(eq15(siteCrawlAttempts.id, attemptId)).run();
       }
     });
   };
   try {
-    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) throw new Error(`Project not found: ${projectId}`);
     const homepageUrl = toHomepageUrl(project.canonicalDomain);
     const maxPages = clampSiteAuditLimit(opts.maxPages ?? opts.limit);
     const maxEdges = clampSiteAuditEdgeLimit(opts.maxEdges);
-    await assertSiteAuditUrlAllowed(homepageUrl, "canonicalDomain");
+    const resolvedRoot = await resolveSiteAuditRootUrl(homepageUrl, {
+      resolveTarget: resolveMeasurementSitemapTarget,
+      signal: opts.signal
+    });
+    const crawlRootUrl = resolvedRoot.effectiveUrl;
     if (opts.sitemapUrl) await assertSiteAuditUrlAllowed(opts.sitemapUrl, "sitemapUrl");
-    log12.info("start", { runId, projectId, homepageUrl, maxPages, maxEdges, maxDepth: opts.maxDepth ?? null });
-    const report = await runSiteCrawl(homepageUrl, {
+    log12.info("start", {
+      runId,
+      projectId,
+      homepageUrl,
+      crawlRootUrl,
+      redirects: resolvedRoot.redirects.length,
+      maxPages,
+      maxEdges,
+      maxDepth: opts.maxDepth ?? null
+    });
+    const report = await runSiteCrawl(crawlRootUrl, {
       mode: "summary",
       sitemapUrl: opts.sitemapUrl,
       maxPages,
@@ -7824,6 +8341,17 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
     if (crawlSummary.complete && !hasAuditedPages) {
       throw emptyCompleteCrawlError(crawlSummary.rootUrl, crawlSummary.finalRootUrl, crawlSummary.pagesObserved);
     }
+    const templateLinks = classifySiteCrawlTemplateLinks(
+      db,
+      { projectId, runId, attemptId },
+      crawlSummary.pagesFetched
+    );
+    log12.info("template-links", {
+      runId,
+      projectId,
+      detection: templateLinks.detection,
+      templateEdges: templateLinks.templateEdgeCount
+    });
     const graphLayout = await prepareSiteCrawlGraphLayout(db, {
       projectId,
       runId,
@@ -7851,6 +8379,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           failureCode: "layout-error",
           totalNodes: graphLayout.totalNodes,
           totalEdges: graphLayout.totalEdges,
+          totalTemplateEdges: graphLayout.totalTemplateEdges,
           nodeCount: 0,
           edgeCount: 0,
           nodes: [],
@@ -7865,14 +8394,14 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
       }
     }
     const published = db.transaction((tx) => {
-      const claim2 = tx.update(runs).set({ status: terminalStatus, finishedAt }).where(and11(eq14(runs.id, runId), eq14(runs.status, "running"))).run();
+      const claim2 = tx.update(runs).set({ status: terminalStatus, finishedAt }).where(and12(eq15(runs.id, runId), eq15(runs.status, "running"))).run();
       if (claim2.changes === 0) return false;
       if (hasAuditedPages) {
         tx.insert(siteAuditSnapshots).values({
           id: crypto17.randomUUID(),
           projectId,
           runId,
-          sitemapUrl: opts.sitemapUrl ?? `${homepageUrl}/sitemap.xml`,
+          sitemapUrl: opts.sitemapUrl ?? new URL("/sitemap.xml", crawlRootUrl).href,
           auditedAt: crawlSummary.completedAt,
           aggregateScore: crawlSummary.auditRollup.aggregateScore ?? 0,
           pagesDiscovered: crawlSummary.pagesDiscovered,
@@ -7904,7 +8433,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         projectId,
         runId,
         attemptId,
-        requestedRootUrl: crawlSummary.rootUrl,
+        requestedRootUrl: resolvedRoot.requestedUrl,
         rootUrl: crawlSummary.finalRootUrl ?? crawlSummary.rootUrl,
         crawlSchemaVersion: crawlSummary.crawlSchemaVersion,
         engineVersion: crawlSummary.engineVersion,
@@ -7935,6 +8464,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         deadLinkState: report.deadLinks.state,
         deadLinksChecked,
         deadLinksFound,
+        templateDetection: templateLinks.detection,
         createdAt: finishedAt,
         updatedAt: finishedAt
       }).run();
@@ -7967,7 +8497,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         edgesDiscovered: crawlSummary.edgesObserved,
         finishedAt,
         updatedAt: finishedAt
-      }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
+      }).where(eq15(siteCrawlAttempts.id, attemptId)).run();
       return true;
     });
     if (!published) {
@@ -7980,7 +8510,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
           error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
         });
       }
-      const current = db.select({ status: runs.status }).from(runs).where(eq14(runs.id, runId)).get();
+      const current = db.select({ status: runs.status }).from(runs).where(eq15(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}`);
     }
@@ -7995,12 +8525,12 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
         error: message,
         finishedAt,
         updatedAt: finishedAt
-      }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
+      }).where(eq15(siteCrawlAttempts.id, attemptId)).run();
       tx.update(runs).set({
         status: cancelled ? "cancelled" : "failed",
         error: message,
         finishedAt
-      }).where(and11(eq14(runs.id, runId), eq14(runs.status, "running"))).run();
+      }).where(and12(eq15(runs.id, runId), eq15(runs.status, "running"))).run();
     });
     log12.error("failed", { runId, projectId, cancelled, error: message });
     throw error;
@@ -8008,7 +8538,7 @@ async function executeSiteAudit(db, runId, projectId, opts = {}) {
 }
 
 // src/commands/backfill.ts
-import { and as and12, eq as eq15, inArray as inArray4, isNull as isNull2, sql as sql7 } from "drizzle-orm";
+import { and as and13, eq as eq16, inArray as inArray5, isNull as isNull2, sql as sql7 } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
@@ -8016,7 +8546,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(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq16(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -8024,10 +8554,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(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(eq15(runs.kind, RunKinds["answer-visibility"])).all();
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and13(
+      eq16(runs.kind, RunKinds["answer-visibility"]),
+      inArray5(runs.projectId, scopedProjects.map((project) => project.id))
+    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq16(runs.kind, RunKinds["answer-visibility"])).all();
     const runIdsByProject = /* @__PURE__ */ new Map();
     for (const run of runRows) {
       const existing = runIdsByProject.get(run.projectId);
@@ -8035,7 +8565,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(eq15(competitors.projectId, project.id)).all().map((row) => row.domain);
+      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq16(competitors.projectId, project.id)).all().map((row) => row.domain);
       const runIds = runIdsByProject.get(project.id) ?? [];
       if (runIds.length === 0) continue;
       const projectDomains = effectiveDomains({
@@ -8058,7 +8588,7 @@ async function backfillAnswerVisibilityCommand(opts) {
           competitorOverlap: querySnapshots.competitorOverlap,
           recommendedCompetitors: querySnapshots.recommendedCompetitors,
           rawResponse: querySnapshots.rawResponse
-        }).from(querySnapshots).where(inArray4(querySnapshots.runId, batchRunIds)).all();
+        }).from(querySnapshots).where(inArray5(querySnapshots.runId, batchRunIds)).all();
         const pendingUpdates = [];
         for (const snapshot of snapshotRows) {
           examined++;
@@ -8128,7 +8658,7 @@ async function backfillAnswerVisibilityCommand(opts) {
           } else {
             db.transaction((tx) => {
               for (const update of pendingUpdates) {
-                tx.update(querySnapshots).set(update.patch).where(eq15(querySnapshots.id, update.id)).run();
+                tx.update(querySnapshots).set(update.patch).where(eq16(querySnapshots.id, update.id)).run();
               }
             });
             updated += pendingUpdates.length;
@@ -8177,13 +8707,13 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 function backfillNormalizedPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq15(gaTrafficSnapshots.projectId, opts.projectId));
+    baseConditions.push(eq16(gaTrafficSnapshots.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaTrafficSnapshots.id,
     landingPage: gaTrafficSnapshots.landingPage,
     landingPageNormalized: gaTrafficSnapshots.landingPageNormalized
-  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and12(...baseConditions) : void 0).all();
+  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and13(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -8198,7 +8728,7 @@ function backfillNormalizedPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq15(gaTrafficSnapshots.id, row.id)).run();
+        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq16(gaTrafficSnapshots.id, row.id)).run();
         updated++;
       }
     });
@@ -8212,7 +8742,7 @@ async function backfillNormalizedPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq15(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq16(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -8249,13 +8779,13 @@ async function backfillNormalizedPathsCommand(opts) {
 function backfillAiReferralPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq15(gaAiReferrals.projectId, opts.projectId));
+    baseConditions.push(eq16(gaAiReferrals.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaAiReferrals.id,
     landingPage: gaAiReferrals.landingPage,
     landingPageNormalized: gaAiReferrals.landingPageNormalized
-  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and12(...baseConditions) : void 0).all();
+  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and13(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -8270,7 +8800,7 @@ function backfillAiReferralPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq15(gaAiReferrals.id, row.id)).run();
+        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq16(gaAiReferrals.id, row.id)).run();
         updated++;
       }
     });
@@ -8284,7 +8814,7 @@ async function backfillAiReferralPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq15(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq16(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -8320,10 +8850,10 @@ async function backfillAiReferralPathsCommand(opts) {
 }
 function backfillProjectAnswerMentions(db, projectId, opts) {
   const isDryRun = opts?.dryRun === true;
-  const project = db.select().from(projects).where(eq15(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq16(projects.id, projectId)).get();
   if (!project) return { examined: 0, updated: 0, mentioned: 0 };
-  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 competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq16(competitors.projectId, projectId)).all().map((row) => row.domain);
+  const runRows = db.select({ id: runs.id }).from(runs).where(and13(eq16(runs.kind, RunKinds["answer-visibility"]), eq16(runs.projectId, projectId))).all();
   const runIds = runRows.map((r) => r.id);
   let examined = 0;
   let updated = 0;
@@ -8351,7 +8881,7 @@ function backfillProjectAnswerMentions(db, projectId, opts) {
       competitorOverlap: querySnapshots.competitorOverlap,
       recommendedCompetitors: querySnapshots.recommendedCompetitors,
       rawResponse: querySnapshots.rawResponse
-    }).from(querySnapshots).where(inArray4(querySnapshots.runId, batchRunIds)).all();
+    }).from(querySnapshots).where(inArray5(querySnapshots.runId, batchRunIds)).all();
     const pendingUpdates = [];
     for (const snapshot of snapshotRows) {
       examined++;
@@ -8397,7 +8927,7 @@ function backfillProjectAnswerMentions(db, projectId, opts) {
       } else {
         db.transaction((tx) => {
           for (const update of pendingUpdates) {
-            tx.update(querySnapshots).set(update.patch).where(eq15(querySnapshots.id, update.id)).run();
+            tx.update(querySnapshots).set(update.patch).where(eq16(querySnapshots.id, update.id)).run();
           }
         });
         updated += pendingUpdates.length;
@@ -8412,7 +8942,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(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq16(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -8472,7 +9002,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-YUUPSJRC.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-DHY5CYWX.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -8631,7 +9161,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
-  const project = db.select().from(projects).where(eq15(projects.name, opts.project)).get();
+  const project = db.select().from(projects).where(eq16(projects.name, opts.project)).get();
   if (!project) {
     throw new Error(`Project "${opts.project}" not found`);
   }
@@ -8642,17 +9172,17 @@ 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(and12(
-    eq15(auditLog.projectId, project.id),
-    inArray4(auditLog.action, ["keywords.appended", "keywords.deleted", "queries.appended", "queries.deleted", "queries.replaced"])
+  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and13(
+    eq16(auditLog.projectId, project.id),
+    inArray5(auditLog.action, ["keywords.appended", "keywords.deleted", "queries.appended", "queries.deleted", "queries.replaced"])
   )).orderBy(auditLog.createdAt).all();
   const history = replayQueryAuditLog(events);
   const orphanRuns = db.select({
     runId: runs.id,
     createdAt: runs.createdAt,
     location: runs.location
-  }).from(runs).innerJoin(querySnapshots, eq15(querySnapshots.runId, runs.id)).where(and12(
-    eq15(runs.projectId, project.id),
+  }).from(runs).innerJoin(querySnapshots, eq16(querySnapshots.runId, runs.id)).where(and13(
+    eq16(runs.projectId, project.id),
     isNull2(querySnapshots.queryId),
     isNull2(querySnapshots.queryText)
   )).groupBy(runs.id).orderBy(runs.createdAt).all();
@@ -8674,8 +9204,8 @@ async function backfillSnapshotAttributionCommand(opts) {
       provider: querySnapshots.provider,
       createdAt: querySnapshots.createdAt,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).where(and12(
-      eq15(querySnapshots.runId, run.runId),
+    }).from(querySnapshots).where(and13(
+      eq16(querySnapshots.runId, run.runId),
       isNull2(querySnapshots.queryId),
       isNull2(querySnapshots.queryText)
     )).orderBy(querySnapshots.provider, querySnapshots.createdAt).all();
@@ -8741,7 +9271,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(eq15(querySnapshots.id, u.id)).run();
+        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq16(querySnapshots.id, u.id)).run();
       }
     });
   }
@@ -8815,7 +9345,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(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq16(projects.name, projectFilter)).all() : db.select().from(projects).all();
   if (scopedProjects.length === 0) {
     if (projectFilter && !isJson) {
       process.stderr.write(`No project named "${projectFilter}".
@@ -8840,9 +9370,9 @@ async function backfillTrafficClassificationCommand(opts) {
     dryRun: isDryRun,
     byBot: {}
   };
-  const unknownCountRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and12(
-    eq15(rawEventSamples.eventType, "unknown"),
-    inArray4(rawEventSamples.projectId, projectIds)
+  const unknownCountRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and13(
+    eq16(rawEventSamples.eventType, "unknown"),
+    inArray5(rawEventSamples.projectId, projectIds)
   )).get();
   result.unknownBefore = Number(unknownCountRow?.n ?? 0);
   const unknownSamples = db.select({
@@ -8853,9 +9383,9 @@ async function backfillTrafficClassificationCommand(opts) {
     userAgent: rawEventSamples.userAgent,
     pathNormalized: rawEventSamples.pathNormalized,
     status: rawEventSamples.status
-  }).from(rawEventSamples).where(and12(
-    eq15(rawEventSamples.eventType, "unknown"),
-    inArray4(rawEventSamples.projectId, projectIds)
+  }).from(rawEventSamples).where(and13(
+    eq16(rawEventSamples.eventType, "unknown"),
+    inArray5(rawEventSamples.projectId, projectIds)
   )).all();
   result.examined = unknownSamples.length;
   if (unknownSamples.length === 0) {
@@ -8893,7 +9423,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(eq15(rawEventSamples.id, snap.id)).run();
+    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq16(rawEventSamples.id, snap.id)).run();
     const tsHour = new Date(snap.ts);
     tsHour.setUTCMinutes(0, 0, 0);
     if (userFetch) {
@@ -8957,9 +9487,9 @@ async function backfillTrafficClassificationCommand(opts) {
     }
   }
   if (!isDryRun) {
-    const afterRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and12(
-      eq15(rawEventSamples.eventType, "unknown"),
-      inArray4(rawEventSamples.projectId, projectIds)
+    const afterRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and13(
+      eq16(rawEventSamples.eventType, "unknown"),
+      inArray5(rawEventSamples.projectId, projectIds)
     )).get();
     result.unknownAfter = Number(afterRow?.n ?? 0);
   } else {
@@ -9392,7 +9922,7 @@ var ProviderRegistry = class {
 // src/scheduler.ts
 import crypto19 from "crypto";
 import cron from "node-cron";
-import { and as and13, eq as eq16, inArray as inArray5, notExists, sql as sql8 } from "drizzle-orm";
+import { and as and14, eq as eq17, inArray as inArray6, notExists, sql as sql8 } from "drizzle-orm";
 var log13 = createLogger("Scheduler");
 var DEFAULT_HEALTH_CRON = "0 */6 * * *";
 function taskKey(projectId, kind) {
@@ -9424,9 +9954,9 @@ var Scheduler = class {
    */
   ensureHealthSchedules() {
     const projectsWithoutHealth = this.db.select({ id: projects.id }).from(projects).where(notExists(
-      this.db.select({ one: sql8`1` }).from(schedules).where(and13(
-        eq16(schedules.projectId, projects.id),
-        eq16(schedules.kind, SchedulableRunKinds.doctor)
+      this.db.select({ one: sql8`1` }).from(schedules).where(and14(
+        eq17(schedules.projectId, projects.id),
+        eq17(schedules.kind, SchedulableRunKinds.doctor)
       ))
     )).all();
     if (projectsWithoutHealth.length === 0) return;
@@ -9477,7 +10007,7 @@ var Scheduler = class {
   start() {
     this.ensureHealthSchedules();
     this.ensureQueryBaskets();
-    const allSchedules = this.db.select().from(schedules).where(eq16(schedules.enabled, true)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq17(schedules.enabled, true)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
@@ -9507,7 +10037,7 @@ var Scheduler = class {
       this.stopTask(key, existing, "Stopped");
       this.tasks.delete(key);
     }
-    const schedule = this.db.select().from(schedules).where(and13(eq16(schedules.projectId, projectId), eq16(schedules.kind, kind))).get();
+    const schedule = this.db.select().from(schedules).where(and14(eq17(schedules.projectId, projectId), eq17(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -9548,21 +10078,21 @@ var Scheduler = class {
     this.db.update(schedules).set({
       nextRunAt: nextRunFromCron(cronExpr, timezone),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq16(schedules.id, scheduleId)).run();
+    }).where(eq17(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(eq16(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq17(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(eq16(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
       if (!project) {
         log13.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
         this.remove(projectId, kind);
@@ -9582,7 +10112,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         log13.info("traffic-sync.triggered", { projectName: project.name, sourceId });
         this.callbacks.onTrafficSyncRequested(project.name, sourceId);
         return;
@@ -9605,7 +10135,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         log13.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onGbpSyncRequested(runId2, projectId);
         return;
@@ -9615,14 +10145,14 @@ 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(and13(
-          eq16(runs.projectId, projectId),
-          eq16(runs.kind, RunKinds["ads-sync"]),
-          inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
+        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and14(
+          eq17(runs.projectId, projectId),
+          eq17(runs.kind, RunKinds["ads-sync"]),
+          inArray6(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(eq16(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq17(schedules.id, currentSchedule.id)).run();
           return;
         }
         const runId2 = crypto19.randomUUID();
@@ -9638,7 +10168,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         log13.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onAdsSyncRequested(runId2, projectId);
         return;
@@ -9652,7 +10182,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         log13.info("data-refresh.triggered", { projectName: project.name });
         this.callbacks.onDataRefreshRequested(project.name);
         return;
@@ -9666,7 +10196,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         log13.info("doctor.triggered", { projectName: project.name });
         this.callbacks.onDoctorRequested(project.name);
         return;
@@ -9680,7 +10210,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         log13.info("backlinks-sync.triggered", { projectName: project.name });
         this.callbacks.onBacklinksSyncRequested(project.name);
         return;
@@ -9690,14 +10220,14 @@ 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(and13(
-          eq16(runs.projectId, projectId),
-          eq16(runs.kind, RunKinds["site-audit"]),
-          inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
+        const active = this.db.select({ id: runs.id }).from(runs).where(and14(
+          eq17(runs.projectId, projectId),
+          eq17(runs.kind, RunKinds["site-audit"]),
+          inArray6(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(eq16(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq17(schedules.id, currentSchedule.id)).run();
           return;
         }
         const runId2 = crypto19.randomUUID();
@@ -9723,7 +10253,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         log13.info("site-audit.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onSiteAuditRequested(runId2, projectId);
         return;
@@ -9756,7 +10286,7 @@ var Scheduler = class {
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
-        }).where(eq16(schedules.id, currentSchedule.id)).run();
+        }).where(eq17(schedules.id, currentSchedule.id)).run();
         return;
       }
       const runId = queueResult.runId;
@@ -9764,7 +10294,7 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq16(schedules.id, currentSchedule.id)).run();
+      }).where(eq17(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) {
@@ -9797,7 +10327,7 @@ async function refreshAllIntegrations(client, projectName) {
 }
 
 // src/notifier.ts
-import { eq as eq17, desc as desc7, and as and14, inArray as inArray6, or as or2 } from "drizzle-orm";
+import { eq as eq18, desc as desc7, and as and15, inArray as inArray7, or as or2 } from "drizzle-orm";
 import crypto20 from "crypto";
 var log15 = createLogger("Notifier");
 var Notifier = class {
@@ -9810,18 +10340,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(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq18(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(eq17(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq18(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(eq17(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq18(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
@@ -9874,7 +10404,7 @@ var Notifier = class {
    * inferred from the absence of a webhook.
    */
   async onHealthChecked(projectId, report) {
-    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq18(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping health notification" });
       return null;
@@ -9905,7 +10435,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(eq17(doctorHealthState.projectId, projectId)).get();
+    const previous = this.db.select().from(doctorHealthState).where(eq18(doctorHealthState.projectId, projectId)).get();
     const previousStatus = previous?.status ?? null;
     let event = null;
     if (previous === void 0) {
@@ -9920,13 +10450,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(eq17(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set(observation).where(eq18(doctorHealthState.projectId, projectId)).run();
     }
     if (!event) {
       log15.info("health.unchanged", { projectId, status, code });
       return null;
     }
-    const notifs = this.db.select().from(notifications).where(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq18(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     const payload = {
       source: "canonry",
       event,
@@ -9950,7 +10480,7 @@ var Notifier = class {
       delivered += 1;
     }
     if (delivered > 0) {
-      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq17(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq18(doctorHealthState.projectId, projectId)).run();
     }
     log15.info("health.notified", { projectId, event, status, code, subscribers: notifs.length, delivered });
     return event;
@@ -9963,11 +10493,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(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq18(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq18(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq18(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = notif.config;
@@ -9997,7 +10527,7 @@ var Notifier = class {
     }
   }
   computeTransitions(runId, projectId) {
-    const thisRun = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
+    const thisRun = this.db.select().from(runs).where(eq18(runs.id, runId)).get();
     if (!thisRun) return [];
     const completeness = measurementRunCompleteness(this.db, runId);
     if (completeness.planned && !completeness.complete) {
@@ -10008,10 +10538,10 @@ var Notifier = class {
       });
       return [];
     }
-    const groupSiblings = this.db.select().from(runs).where(and14(
-      eq17(runs.projectId, projectId),
-      eq17(runs.kind, thisRun.kind),
-      eq17(runs.createdAt, thisRun.createdAt)
+    const groupSiblings = this.db.select().from(runs).where(and15(
+      eq18(runs.projectId, projectId),
+      eq18(runs.kind, thisRun.kind),
+      eq18(runs.createdAt, thisRun.createdAt)
     )).all();
     const stillPending = groupSiblings.some((r) => r.status === "queued" || r.status === "running");
     if (stillPending) return [];
@@ -10027,17 +10557,17 @@ var Notifier = class {
       return candidate.id > best.id ? candidate : best;
     });
     if (winner.id !== runId) return [];
-    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq17(projects.id, projectId)).get();
+    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq18(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(
-      and14(
-        eq17(runs.projectId, projectId),
-        eq17(runs.kind, thisRun.kind),
-        or2(eq17(runs.status, "completed"), eq17(runs.status, "partial"))
+      and15(
+        eq18(runs.projectId, projectId),
+        eq18(runs.kind, thisRun.kind),
+        or2(eq18(runs.status, "completed"), eq18(runs.status, "partial"))
       )
     ).orderBy(desc7(runs.createdAt), desc7(runs.id)).limit(RECENT_FETCH_LIMIT).all();
     const groups = groupRunsByCreatedAt(recentRuns);
@@ -10054,13 +10584,13 @@ var Notifier = class {
       provider: querySnapshots.provider,
       location: querySnapshots.location,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(queries, eq17(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
+    }).from(querySnapshots).leftJoin(queries, eq18(querySnapshots.queryId, queries.id)).where(inArray7(querySnapshots.runId, currentRunIds)).all();
     const previousSnapshots = this.db.select({
       queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
       location: querySnapshots.location,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).where(inArray6(querySnapshots.runId, previousRunIds)).all();
+    }).from(querySnapshots).where(inArray7(querySnapshots.runId, previousRunIds)).all();
     const prevMap = /* @__PURE__ */ new Map();
     for (const s of previousSnapshots) {
       if (s.queryId == null) continue;
@@ -10137,7 +10667,7 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-import { eq as eq18 } from "drizzle-orm";
+import { eq as eq19 } from "drizzle-orm";
 var log16 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(db, notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
@@ -10153,7 +10683,7 @@ var RunCoordinator = class {
   onInsightsGenerated;
   onAeroEvent;
   async onRunCompleted(runId, projectId) {
-    const runRow = this.db.select().from(runs).where(eq18(runs.id, runId)).get();
+    const runRow = this.db.select().from(runs).where(eq19(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 });
@@ -10244,7 +10774,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(eq18(discoverySessions.runId, runId)).get();
+    const session = this.db.select().from(discoverySessions).where(eq19(discoverySessions.runId, runId)).get();
     const competitorMap = session ? session.competitorMap : [];
     return {
       kind: RunKinds["aeo-discover-probe"],
@@ -10287,7 +10817,7 @@ function analysisResultFromInsights(insights2) {
 
 // src/agent/session-registry.ts
 import crypto24 from "crypto";
-import { eq as eq20 } from "drizzle-orm";
+import { eq as eq21 } from "drizzle-orm";
 
 // src/agent/session.ts
 import fs7 from "fs";
@@ -11416,7 +11946,7 @@ async function loadExternalMcpTools(servers, opts = {}) {
 
 // src/agent/memory-store.ts
 import crypto23 from "crypto";
-import { and as and15, desc as desc8, eq as eq19, like, sql as sql9 } from "drizzle-orm";
+import { and as and16, desc as desc8, eq as eq20, like, sql as sql9 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -11430,7 +11960,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq19(agentMemory.projectId, projectId)).orderBy(desc8(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq20(agentMemory.projectId, projectId)).orderBy(desc8(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -11461,12 +11991,12 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and15(eq19(agentMemory.projectId, args.projectId), eq19(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and16(eq20(agentMemory.projectId, args.projectId), eq20(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(and15(eq19(agentMemory.projectId, projectId), eq19(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and16(eq20(agentMemory.projectId, projectId), eq20(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -11495,8 +12025,8 @@ function writeCompactionNote(db, args) {
     }).run();
     const sessionPrefix = `${COMPACTION_KEY_PREFIX}${args.sessionId}:`;
     const existing = tx.select({ id: agentMemory.id, updatedAt: agentMemory.updatedAt }).from(agentMemory).where(
-      and15(
-        eq19(agentMemory.projectId, args.projectId),
+      and16(
+        eq20(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
     ).orderBy(desc8(agentMemory.updatedAt)).all();
@@ -11504,7 +12034,7 @@ function writeCompactionNote(db, args) {
     if (stale.length > 0) {
       tx.delete(agentMemory).where(sql9`${agentMemory.id} IN (${sql9.join(stale.map((s) => sql9`${s}`), sql9`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and15(eq19(agentMemory.projectId, args.projectId), eq19(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and16(eq20(agentMemory.projectId, args.projectId), eq20(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -11731,7 +12261,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq20(agentSessions.projectId, projectId)).run();
+        }).where(eq21(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -11965,7 +12495,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq20(agentSessions.projectId, projectId)).run();
+    }).where(eq21(agentSessions.projectId, projectId)).run();
   }
   /** Persist a session's transcript back to the DB. Call after any run settles. */
   save(projectName) {
@@ -12129,11 +12659,11 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq20(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq21(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq20(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq21(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
@@ -12152,14 +12682,14 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq20(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq21(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/agent-routes.ts
-import { eq as eq21 } from "drizzle-orm";
+import { eq as eq22 } from "drizzle-orm";
 function resolveProject(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq21(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq22(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -12168,7 +12698,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(eq21(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq22(agentSessions.projectId, project.id)).get();
       if (!row) {
         return { messages: [], modelProvider: null, modelId: null, updatedAt: null };
       }
@@ -12192,7 +12722,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(eq21(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -12519,16 +13049,16 @@ Your previous reply was not valid JSON. Return ONLY a JSON object with exactly t
 import { runAeoAudit } from "@canonry/aeo-audit";
 
 // src/site-fetch.ts
-import https from "https";
+import https2 from "https";
 var FETCH_TIMEOUT_MS2 = 1e4;
 var MAX_TEXT_LENGTH = 4e3;
 var MAX_BODY_BYTES = 512e3;
-var USER_AGENT = "Canonry/1.0 (site-analysis)";
+var USER_AGENT2 = "Canonry/1.0 (site-analysis)";
 function fetchWithPinnedAddress(target) {
   return new Promise((resolve) => {
     const port = target.url.port ? Number(target.url.port) : 443;
     const path10 = target.url.pathname + target.url.search;
-    const req = https.request(
+    const req = https2.request(
       {
         hostname: target.address,
         family: target.family,
@@ -12540,7 +13070,7 @@ function fetchWithPinnedAddress(target) {
         // SNI for TLS
         headers: {
           Host: target.url.host,
-          "User-Agent": USER_AGENT,
+          "User-Agent": USER_AGENT2,
           Accept: "text/html"
         }
       },
@@ -13135,20 +13665,20 @@ function clipText(value, length) {
 }
 
 // src/research-runner.ts
-import { and as and16, eq as eq22, inArray as inArray7, sql as sql10 } from "drizzle-orm";
+import { and as and17, eq as eq23, inArray as inArray8, 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(and16(eq22(researchRuns.id, runId), eq22(researchRuns.projectId, projectId))).get();
+  const run = db.select().from(researchRuns).where(and17(eq23(researchRuns.id, runId), eq23(researchRuns.projectId, projectId))).get();
   if (!run || run.status !== ResearchRunStatuses.queued) return;
-  const project = db.select().from(projects).where(eq22(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq23(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(and16(eq22(researchRuns.id, runId), eq22(researchRuns.status, ResearchRunStatuses.queued))).run();
+  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and17(eq23(researchRuns.id, runId), eq23(researchRuns.status, ResearchRunStatuses.queued))).run();
   if (claim.changes !== 1) return;
   let reserved = 0;
   let dispatched = 0;
@@ -13172,8 +13702,8 @@ async function executeResearchRun(db, registry, runId, projectId) {
     }
     reserved = run.totalQueries;
     reservation = { scope, period };
-    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 rows = db.select().from(researchRunQueries).where(eq23(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
+    const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq23(competitors.projectId, projectId)).all().map((row) => row.domain);
     const domains = effectiveDomains(project);
     const brands = effectiveBrandNames(project);
     const config = { ...provider.config, model: run.resolvedModel };
@@ -13181,7 +13711,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(and16(eq22(researchRunQueries.id, row.id), eq22(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
+        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and17(eq23(researchRunQueries.id, row.id), eq23(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);
@@ -13208,7 +13738,7 @@ async function executeResearchRun(db, registry, runId, projectId) {
           citationState: determineCitationState(normalized, domains),
           rawResponse: raw.rawResponse,
           finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(and16(eq22(researchRunQueries.id, row.id), eq22(researchRunQueries.status, ResearchQueryStatuses.running))).run();
+        }).where(and17(eq23(researchRunQueries.id, row.id), eq23(researchRunQueries.status, ResearchQueryStatuses.running))).run();
         if (completed.changes === 1) incrementResearchProgress(db, runId, "completedQueries");
       } catch (error) {
         try {
@@ -13232,18 +13762,18 @@ async function executeResearchRun(db, registry, runId, projectId) {
   }
 }
 function incrementResearchProgress(db, runId, column) {
-  db.update(researchRuns).set({ [column]: sql10`${researchRuns[column]} + 1` }).where(eq22(researchRuns.id, runId)).run();
+  db.update(researchRuns).set({ [column]: sql10`${researchRuns[column]} + 1` }).where(eq23(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(and16(eq22(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(and17(eq23(researchRunQueries.id, queryId), inArray8(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(and16(eq22(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and17(eq23(researchRunQueries.researchRunId, runId), inArray8(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
 }
 function finalizeResearchRun(db, runId, fatalError) {
-  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq22(researchRunQueries.researchRunId, runId)).all();
+  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq23(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({
@@ -13252,7 +13782,7 @@ function finalizeResearchRun(db, runId, fatalError) {
     failedQueries: failed,
     error: fatalError ?? (failed === rows.length ? "Every research query failed." : null),
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq22(researchRuns.id, runId)).run();
+  }).where(eq23(researchRuns.id, runId)).run();
 }
 
 // src/server.ts
@@ -13290,6 +13820,13 @@ function resolveDashboardShowResourceLinks(env, config) {
 function resolveDashboardShowUpdateNotification(env, config) {
   return parseBooleanEnv(env.CANONRY_DASHBOARD_SHOW_UPDATE_NOTIFICATION) ?? config.dashboard?.showUpdateNotification ?? true;
 }
+function parseDashboardOnboardingMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized === "legacy" || normalized === "platform" || normalized === "auto" ? normalized : void 0;
+}
+function resolveDashboardOnboardingMode(env, config) {
+  return parseDashboardOnboardingMode(env.CANONRY_ONBOARDING_MODE) ?? config.dashboard?.onboardingMode;
+}
 var API_ADAPTERS = [
   geminiAdapter,
   openaiAdapter,
@@ -13567,7 +14104,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(eq23(projects.id, ctx.projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq24(projects.id, ctx.projectId)).get();
       if (!project) return;
       let content;
       if (ctx.kind === RunKinds["aeo-discover-probe"]) {
@@ -13917,7 +14454,7 @@ async function createServer(opts) {
       void (async () => {
         try {
           const report = await aeroClient.runDoctor({ project: projectName });
-          const project = opts.db.select().from(projects).where(eq23(projects.name, projectName)).get();
+          const project = opts.db.select().from(projects).where(eq24(projects.name, projectName)).get();
           if (!project) {
             app.log.warn({ projectName }, "doctor schedule fired for an unknown project");
             return;
@@ -13945,9 +14482,9 @@ async function createServer(opts) {
         });
         if (!probed) return;
         const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(
-          and17(
-            eq23(ccReleaseSyncs.release, probed.release),
-            eq23(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
+          and18(
+            eq24(ccReleaseSyncs.release, probed.release),
+            eq24(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
           )
         ).limit(1).get();
         if (alreadySynced) {
@@ -14187,6 +14724,7 @@ async function createServer(opts) {
   const dashboardRequirePassword = resolveDashboardRequirePassword(process.env, opts.config);
   const dashboardShowResourceLinks = resolveDashboardShowResourceLinks(process.env, opts.config);
   const dashboardShowUpdateNotification = resolveDashboardShowUpdateNotification(process.env, opts.config);
+  const dashboardOnboardingMode = resolveDashboardOnboardingMode(process.env, opts.config);
   app.log.info(
     { dashboardRequirePassword },
     "Dashboard password gate resolved"
@@ -14195,7 +14733,7 @@ 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(eq23(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq24(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
@@ -14247,7 +14785,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq24(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -14271,7 +14809,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(eq23(apiKeys.keyHash, hashApiKey(parts[1]))).get();
+    const key = opts.db.select().from(apiKeys).where(eq24(apiKeys.keyHash, hashApiKey(parts[1]))).get();
     return Boolean(key && !key.revokedAt);
   };
   const namedAccountsInUse = () => anyUsersExist(opts.db);
@@ -14361,12 +14899,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq24(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(eq23(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq24(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header(
         "set-cookie",
@@ -14708,7 +15246,7 @@ async function createServer(opts) {
         ...inspectOpts,
         config: opts.config
       }).then(() => {
-        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq23(runs.id, runId)).get();
+        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq24(runs.id, runId)).get();
         if (finished?.status === RunStatuses.completed || finished?.status === RunStatuses.partial) {
           return maybeRefreshGscCoverage(
             opts.db,
@@ -14985,6 +15523,9 @@ async function createServer(opts) {
       const clientConfig = {};
       if (basePath) clientConfig.basePath = basePath;
       const dashboardConfig = {};
+      if (dashboardOnboardingMode) {
+        dashboardConfig.onboardingMode = dashboardOnboardingMode;
+      }
       if (!dashboardShowResourceLinks) {
         dashboardConfig.showResourceLinks = false;
       }
@@ -15086,7 +15627,7 @@ async function createServer(opts) {
   }
   checkLatestVersionForServer();
   scheduler.start();
-  for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq23(researchRuns.status, ResearchRunStatuses.queued)).all()) {
+  for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq24(researchRuns.status, ResearchRunStatuses.queued)).all()) {
     dispatchResearchRun(run.id, run.projectId);
   }
   app.addHook("onClose", async () => {