@canonry/canonry 4.154.1 → 4.156.0

package/dist/{chunk-JOP2DGXL.js → chunk-ZWESOFA5.js}

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-ANSQ6JNO.js";
+} from "./chunk-CPASKGUE.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -124,9 +124,19 @@ import {
   schedules,
   siteAuditPages,
   siteAuditSnapshots,
+  siteCrawlAttempts,
+  siteCrawlEdges,
+  siteCrawlEventReceipts,
+  siteCrawlFindings,
+  siteCrawlGraphEdges,
+  siteCrawlGraphLayouts,
+  siteCrawlGraphNodes,
+  siteCrawlPages,
+  siteCrawlRunRequests,
+  siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-KRMLGFY3.js";
+} from "./chunk-ABNN2ZVR.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -151,6 +161,12 @@ import {
   RunKinds,
   RunStatuses,
   RunTriggers,
+  SITE_AUDIT_DEFAULT_EDGE_LIMIT,
+  SITE_AUDIT_DEFAULT_PAGE_LIMIT,
+  SITE_AUDIT_MAX_EDGE_LIMIT,
+  SITE_AUDIT_MAX_PAGE_LIMIT,
+  SITE_CRAWL_GRAPH_MAX_EDGES,
+  SITE_CRAWL_GRAPH_MAX_NODES,
   SKILL_MANIFEST_FILENAME,
   SchedulableRunKinds,
   SkillsClients,
@@ -200,6 +216,7 @@ import {
   normalizeIdTokens,
   normalizeMeasurementExecutionQueryText,
   normalizeServedModel,
+  normalizeSiteAuditRunRequest,
   normalizeUrlPath,
   notFound,
   parseMeasurementRunManifestV1,
@@ -210,6 +227,7 @@ import {
   resolveSnapshotRequestQueries,
   serializeForInlineScript,
   serializeRunError,
+  siteAuditRequestIdentity,
   skillsClientSchema,
   splitList,
   startOfDayHourInTimeZone,
@@ -218,7 +236,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-NNW7TJUZ.js";
+} from "./chunk-AMPT2EP7.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -548,12 +566,12 @@ function checkLatestVersionForServer(opts) {
 }
 
 // src/server.ts
-import { createRequire as createRequire3 } from "module";
-import crypto24 from "crypto";
+import { createRequire as createRequire4 } from "module";
+import crypto25 from "crypto";
 import fs8 from "fs";
 import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { and as and15, eq as eq22 } from "drizzle-orm";
+import { and as and17, eq as eq23 } from "drizzle-orm";
 import Fastify from "fastify";
 import os5 from "os";
 
@@ -3547,11 +3565,23 @@ var JobRunner = class {
     this.registry = registry;
   }
   recoverStaleRuns() {
-    const stale = this.db.select({ id: runs.id, status: runs.status }).from(runs).where(inArray(runs.status, ["running", "queued"])).all();
+    const stale = this.db.select({ id: runs.id, projectId: runs.projectId, kind: runs.kind, status: runs.status }).from(runs).where(inArray(runs.status, ["running", "queued"])).all();
     if (stale.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const run of stale) {
-      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq2(runs.id, run.id)).run();
+      const recovered = this.db.transaction((tx) => {
+        const claim = tx.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(and2(eq2(runs.id, run.id), eq2(runs.status, run.status))).run();
+        if (claim.changes === 0) return false;
+        if (run.kind === RunKinds["site-audit"]) {
+          tx.update(siteCrawlAttempts).set({ state: "failed", finishedAt: now, updatedAt: now, error: "Server restarted while run was in progress" }).where(and2(
+            eq2(siteCrawlAttempts.projectId, run.projectId),
+            eq2(siteCrawlAttempts.runId, run.id),
+            inArray(siteCrawlAttempts.state, ["queued", "running"])
+          )).run();
+        }
+        return true;
+      });
+      if (!recovered) continue;
       log.warn("run.recovered-stale", { runId: run.id, previousStatus: run.status });
     }
   }
@@ -4119,7 +4149,7 @@ var JobRunner = class {
       }
     }
   }
-  incrementUsage(scope, metric, count) {
+  incrementUsage(scope, metric, count2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const period = now.slice(0, 10);
     this.db.insert(usageCounters).values({
@@ -4127,11 +4157,11 @@ var JobRunner = class {
       scope,
       period,
       metric,
-      count,
+      count: count2,
       updatedAt: now
     }).onConflictDoUpdate({
       target: [usageCounters.scope, usageCounters.period, usageCounters.metric],
-      set: { count: sql2`${usageCounters.count} + ${count}`, updatedAt: now }
+      set: { count: sql2`${usageCounters.count} + ${count2}`, updatedAt: now }
     }).run();
   }
   flushProviderUsage(providerDispatchCounts, providerReservations) {
@@ -4250,8 +4280,19 @@ function writeCoverageSnapshot(db, projectId, runId, opts = {}) {
   const since = isoDaysAgo(windowDays);
   const pageRows = db.select({ page: gscSearchData.page, impressions: gscSearchData.impressions }).from(gscSearchData).where(and3(eq3(gscSearchData.projectId, projectId), gte(gscSearchData.date, since))).all();
   const allInspections = db.select().from(gscUrlInspections).where(eq3(gscUrlInspections.projectId, projectId)).all();
+  const latestCrawl = db.select({ runId: siteCrawlSnapshots.runId, attemptId: siteCrawlSnapshots.attemptId }).from(siteCrawlSnapshots).innerJoin(runs, eq3(siteCrawlSnapshots.runId, runs.id)).where(and3(
+    eq3(siteCrawlSnapshots.projectId, projectId),
+    eq3(siteCrawlSnapshots.complete, true),
+    eq3(runs.status, "completed")
+  )).orderBy(desc(siteCrawlSnapshots.createdAt)).limit(1).get();
+  const hasCrawlHistory = Boolean(db.select({ id: siteCrawlSnapshots.id }).from(siteCrawlSnapshots).where(eq3(siteCrawlSnapshots.projectId, projectId)).limit(1).get());
   const latestAudit = db.select({ runId: siteAuditSnapshots.runId }).from(siteAuditSnapshots).where(eq3(siteAuditSnapshots.projectId, projectId)).orderBy(desc(siteAuditSnapshots.createdAt)).limit(1).get();
-  const sitemapUrls = latestAudit ? db.select({ url: siteAuditPages.url }).from(siteAuditPages).where(eq3(siteAuditPages.runId, latestAudit.runId)).all() : [];
+  const sitemapUrls = latestCrawl?.attemptId ? db.select({ url: siteCrawlPages.url }).from(siteCrawlPages).where(and3(
+    eq3(siteCrawlPages.projectId, projectId),
+    eq3(siteCrawlPages.runId, latestCrawl.runId),
+    eq3(siteCrawlPages.attemptId, latestCrawl.attemptId),
+    eq3(siteCrawlPages.inventoryEligible, true)
+  )).all() : !hasCrawlHistory && latestAudit ? db.select({ url: siteAuditPages.url }).from(siteAuditPages).where(eq3(siteAuditPages.runId, latestAudit.runId)).all() : [];
   const impressionsByKey = /* @__PURE__ */ new Map();
   for (const row of pageRows) {
     const key = pageKey(row.page);
@@ -6894,165 +6935,1021 @@ 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 { runSiteCrawl } from "@canonry/aeo-audit";
+
+// src/site-crawl-graph-layout.ts
 import crypto16 from "crypto";
-import { eq as eq13 } from "drizzle-orm";
-import { runSitemapAudit } from "@ainyc/aeo-audit";
+import { createRequire as createRequire3 } from "module";
+import { Worker } from "worker_threads";
+import { and as and10, asc, count, desc as desc6, eq as eq13, isNull, ne as ne2, or, sql as sql5 } from "drizzle-orm";
+import { alias } from "drizzle-orm/sqlite-core";
+var SITE_CRAWL_GRAPH_LAYOUT_VERSION = "site-health-fa2-v1";
+var SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS = 15e3;
+var SITE_CRAWL_GRAPH_SEED_SCALE = 100;
+var graphSourcePage = alias(siteCrawlPages, "layout_graph_source_page");
+var graphTargetPage = alias(siteCrawlPages, "layout_graph_target_page");
+var FORCE_ATLAS_SETTINGS = Object.freeze({
+  adjustSizes: false,
+  barnesHutOptimize: true,
+  barnesHutTheta: 0.5,
+  edgeWeightInfluence: 0.5,
+  gravity: 1,
+  linLogMode: false,
+  outboundAttractionDistribution: false,
+  scalingRatio: 10,
+  slowDown: 10,
+  strongGravityMode: false
+});
+var WORKER_SOURCE = String.raw`
+const {parentPort, workerData} = require('node:worker_threads');
+try {
+  const graphologyModule = require(workerData.graphologyPath);
+  const forceAtlasModule = require(workerData.forceAtlasPath);
+  const MultiDirectedGraph = graphologyModule.MultiDirectedGraph;
+  const forceAtlas2 = forceAtlasModule.default || forceAtlasModule;
+  const graph = new MultiDirectedGraph({allowSelfLoops: true});
+  for (const node of workerData.input.nodes) {
+    graph.addNode(node.nodeKey, {x: node.x, y: node.y});
+  }
+  for (const edge of workerData.input.edges) {
+    graph.addDirectedEdgeWithKey(edge.edgeKey, edge.sourceNodeKey, edge.targetNodeKey, {
+      weight: 1 + Math.log2(Math.max(1, edge.occurrences)),
+    });
+  }
+  if (graph.order > 1 && graph.size > 0) {
+    forceAtlas2.assign(graph, {
+      iterations: workerData.input.iterations,
+      settings: workerData.settings,
+    });
+  }
+  const positions = [];
+  graph.forEachNode((nodeKey, attributes) => {
+    positions.push({nodeKey, x: attributes.x, y: attributes.y});
+  });
+  parentPort.postMessage({ok: true, positions});
+} catch (error) {
+  parentPort.postMessage({
+    ok: false,
+    error: error && typeof error.message === 'string' ? error.message : String(error),
+  });
+}
+`;
+var GraphLayoutTimeoutError = class extends Error {
+  name = "GraphLayoutTimeoutError";
+};
+function hashUnit(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967296;
+}
+function pathSection(path10) {
+  return path10.split("/").filter(Boolean)[0] ?? "__root__";
+}
+function seedSiteCrawlGraphNodes(nodes, rootNodeKey, priorPositions) {
+  return [...nodes].sort((a, b) => a.sampleRank - b.sampleRank || a.nodeKey.localeCompare(b.nodeKey)).map((node) => {
+    const prior = priorPositions?.get(node.nodeKey);
+    if (prior && Number.isFinite(prior.x) && Number.isFinite(prior.y)) {
+      return {
+        ...node,
+        x: prior.x * SITE_CRAWL_GRAPH_SEED_SCALE,
+        y: prior.y * SITE_CRAWL_GRAPH_SEED_SCALE
+      };
+    }
+    if (node.nodeKey === rootNodeKey) return { ...node, x: 0, y: 0 };
+    const section = pathSection(node.path);
+    const sectionAngle = hashUnit(`section:${section}`) * Math.PI * 2;
+    const sectionRadius = section === "__root__" ? 24 : 100;
+    const clusterX = Math.cos(sectionAngle) * sectionRadius;
+    const clusterY = Math.sin(sectionAngle) * sectionRadius;
+    const localAngle = hashUnit(`node-angle:${node.nodeKey}`) * Math.PI * 2;
+    const depth = Math.max(0, Math.min(12, node.depth ?? 4));
+    const localRadius = 4 + depth * 2.5 + Math.sqrt(hashUnit(`node-radius:${node.nodeKey}`)) * 14;
+    return {
+      ...node,
+      x: clusterX + Math.cos(localAngle) * localRadius,
+      y: clusterY + Math.sin(localAngle) * localRadius
+    };
+  });
+}
+function adaptiveForceAtlasIterations(nodeCount, edgeCount) {
+  if (nodeCount <= 100 && edgeCount <= 500) return 100;
+  if (nodeCount <= 500 && edgeCount <= 2500) return 70;
+  if (nodeCount <= 2e3 && edgeCount <= 1e4) return 40;
+  if (nodeCount <= 5e3 && edgeCount <= 2e4) return 24;
+  if (nodeCount <= 1e4 && edgeCount <= 35e3) return 12;
+  return 6;
+}
+async function computeForceAtlasPositions(input, options = {}) {
+  if (input.nodes.length <= 1 || input.edges.length === 0) {
+    return input.nodes.map(({ nodeKey, x, y }) => ({ nodeKey, x, y }));
+  }
+  const requireFromPackage = createRequire3(import.meta.url);
+  const worker = new Worker(WORKER_SOURCE, {
+    eval: true,
+    workerData: {
+      graphologyPath: requireFromPackage.resolve("graphology"),
+      forceAtlasPath: requireFromPackage.resolve("graphology-layout-forceatlas2"),
+      input,
+      settings: FORCE_ATLAS_SETTINGS
+    }
+  });
+  const timeoutMs = options.timeoutMs ?? SITE_CRAWL_GRAPH_LAYOUT_TIMEOUT_MS;
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      void worker.terminate();
+      if (result.error) reject(result.error instanceof Error ? result.error : new Error("Graph layout failed with a non-Error reason", { cause: result.error }));
+      else resolve(result.positions ?? []);
+    };
+    const onAbort = () => finish({ error: options.signal?.reason ?? new DOMException("Layout aborted", "AbortError") });
+    const timer = setTimeout(() => finish({ error: new GraphLayoutTimeoutError(`Graph layout exceeded ${timeoutMs}ms`) }), timeoutMs);
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted) return onAbort();
+    worker.once("message", (message) => {
+      if (!message.ok) finish({ error: new Error(message.error ?? "Graph layout worker failed") });
+      else finish({ positions: message.positions });
+    });
+    worker.once("error", (error) => finish({ error }));
+    worker.once("exit", (code) => {
+      if (code !== 0 && !settled) finish({ error: new Error(`Graph layout worker exited with code ${code}`) });
+    });
+  });
+}
+function normalizePositions(seededNodes, computed, rootNodeKey) {
+  const byKey = new Map(computed.map((position) => [position.nodeKey, position]));
+  if (byKey.size !== seededNodes.length) throw new Error("Graph layout returned an incomplete node set");
+  const root = rootNodeKey ? byKey.get(rootNodeKey) : null;
+  const centerX = root?.x ?? computed.reduce((sum, position) => sum + position.x, 0) / Math.max(1, computed.length);
+  const centerY = root?.y ?? computed.reduce((sum, position) => sum + position.y, 0) / Math.max(1, computed.length);
+  if (!Number.isFinite(centerX) || !Number.isFinite(centerY)) throw new Error("Graph layout returned a non-finite center");
+  let scale = 0;
+  for (const position of computed) {
+    if (!Number.isFinite(position.x) || !Number.isFinite(position.y)) throw new Error("Graph layout returned non-finite coordinates");
+    scale = Math.max(scale, Math.abs(position.x - centerX), Math.abs(position.y - centerY));
+  }
+  scale = scale > 0 ? scale : 1;
+  return seededNodes.map((node) => {
+    const position = byKey.get(node.nodeKey);
+    if (!position) throw new Error(`Graph layout omitted ${node.nodeKey}`);
+    return {
+      nodeKey: node.nodeKey,
+      sampleRank: node.sampleRank,
+      x: Math.round((position.x - centerX) / scale * 1e6) / 1e6,
+      y: Math.round((position.y - centerY) / scale * 1e6) / 1e6
+    };
+  });
+}
+async function layoutSiteCrawlGraphInput(input, options = {}) {
+  options.signal?.throwIfAborted();
+  if (input.nodes.length === 0) {
+    return {
+      state: "unavailable",
+      failureCode: "empty-crawl",
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+  const seeded = seedSiteCrawlGraphNodes(input.nodes, input.rootNodeKey, input.priorPositions);
+  try {
+    const compute = options.computePositions ?? computeForceAtlasPositions;
+    const positions = await compute({
+      nodes: seeded,
+      edges: input.edges,
+      iterations: adaptiveForceAtlasIterations(input.nodes.length, input.edges.length)
+    }, { signal: options.signal, timeoutMs: options.timeoutMs });
+    options.signal?.throwIfAborted();
+    return {
+      state: "ready",
+      layoutVersion: SITE_CRAWL_GRAPH_LAYOUT_VERSION,
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      nodeCount: input.nodes.length,
+      edgeCount: input.edges.length,
+      nodes: normalizePositions(seeded, positions, input.rootNodeKey),
+      edges: input.edges.map((edge, sampleRank) => ({ ...edge, sampleRank }))
+    };
+  } catch (error) {
+    if (options.signal?.aborted) options.signal.throwIfAborted();
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    return {
+      state: "unavailable",
+      failureCode: error instanceof GraphLayoutTimeoutError ? "layout-timeout" : "layout-error",
+      totalNodes: input.totalNodes,
+      totalEdges: input.totalEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+}
+function loadPriorSiteCrawlGraphPositions(db, scope) {
+  const prior = db.select({
+    runId: siteCrawlSnapshots.runId,
+    attemptId: siteCrawlSnapshots.attemptId
+  }).from(siteCrawlSnapshots).innerJoin(siteCrawlGraphLayouts, and10(
+    eq13(siteCrawlGraphLayouts.projectId, siteCrawlSnapshots.projectId),
+    eq13(siteCrawlGraphLayouts.runId, siteCrawlSnapshots.runId),
+    eq13(siteCrawlGraphLayouts.attemptId, siteCrawlSnapshots.attemptId)
+  )).where(and10(
+    eq13(siteCrawlSnapshots.projectId, scope.projectId),
+    ne2(siteCrawlSnapshots.runId, scope.runId),
+    eq13(siteCrawlSnapshots.complete, true),
+    eq13(siteCrawlGraphLayouts.state, "ready"),
+    eq13(siteCrawlGraphLayouts.layoutVersion, SITE_CRAWL_GRAPH_LAYOUT_VERSION)
+  )).orderBy(desc6(siteCrawlSnapshots.createdAt), desc6(siteCrawlSnapshots.id)).limit(1).get();
+  if (!prior?.attemptId) return /* @__PURE__ */ new Map();
+  return new Map(db.select({
+    nodeKey: siteCrawlGraphNodes.nodeKey,
+    x: siteCrawlGraphNodes.x,
+    y: siteCrawlGraphNodes.y
+  }).from(siteCrawlGraphNodes).where(and10(
+    eq13(siteCrawlGraphNodes.projectId, scope.projectId),
+    eq13(siteCrawlGraphNodes.runId, prior.runId),
+    eq13(siteCrawlGraphNodes.attemptId, prior.attemptId)
+  )).all().map((node) => [node.nodeKey, { x: node.x, y: node.y }]));
+}
+async function prepareSiteCrawlGraphLayout(db, scope, options = {}) {
+  let totalNodes = 0;
+  let totalEdges = 0;
+  try {
+    const assertNotAborted = () => options.signal?.throwIfAborted();
+    assertNotAborted();
+    const pageScope = [
+      eq13(siteCrawlPages.projectId, scope.projectId),
+      eq13(siteCrawlPages.runId, scope.runId),
+      eq13(siteCrawlPages.attemptId, scope.attemptId)
+    ];
+    const edgeScope = [
+      eq13(siteCrawlEdges.projectId, scope.projectId),
+      eq13(siteCrawlEdges.runId, scope.runId),
+      eq13(siteCrawlEdges.attemptId, scope.attemptId),
+      eq13(siteCrawlEdges.internal, true),
+      eq13(siteCrawlEdges.relation, "anchor")
+    ];
+    totalNodes = db.select({ value: count() }).from(siteCrawlPages).where(and10(...pageScope)).get()?.value ?? 0;
+    assertNotAborted();
+    totalEdges = db.select({ value: count() }).from(siteCrawlEdges).innerJoin(graphSourcePage, and10(
+      eq13(graphSourcePage.projectId, scope.projectId),
+      eq13(graphSourcePage.runId, scope.runId),
+      eq13(graphSourcePage.attemptId, scope.attemptId),
+      eq13(graphSourcePage.nodeKey, siteCrawlEdges.sourceNodeKey)
+    )).innerJoin(graphTargetPage, and10(
+      eq13(graphTargetPage.projectId, scope.projectId),
+      eq13(graphTargetPage.runId, scope.runId),
+      eq13(graphTargetPage.attemptId, scope.attemptId),
+      eq13(graphTargetPage.nodeKey, siteCrawlEdges.targetNodeKey)
+    )).where(and10(...edgeScope)).get()?.value ?? 0;
+    assertNotAborted();
+    const graphSeedColumns = {
+      nodeKey: siteCrawlPages.nodeKey,
+      path: siteCrawlPages.path,
+      depth: siteCrawlPages.depth
+    };
+    const rootRows = db.select(graphSeedColumns).from(siteCrawlPages).where(and10(...pageScope, eq13(siteCrawlPages.url, scope.rootUrl))).orderBy(asc(siteCrawlPages.nodeKey)).limit(1).all();
+    assertNotAborted();
+    const retainedRows = [...rootRows];
+    if (retainedRows.length < SITE_CRAWL_GRAPH_MAX_NODES) {
+      retainedRows.push(...db.select(graphSeedColumns).from(siteCrawlPages).where(and10(...pageScope, eq13(siteCrawlPages.depth, 0), ne2(siteCrawlPages.url, scope.rootUrl))).orderBy(asc(siteCrawlPages.nodeKey)).limit(SITE_CRAWL_GRAPH_MAX_NODES - retainedRows.length).all());
+    }
+    assertNotAborted();
+    if (retainedRows.length < SITE_CRAWL_GRAPH_MAX_NODES) {
+      retainedRows.push(...db.select(graphSeedColumns).from(siteCrawlPages).where(and10(
+        ...pageScope,
+        or(isNull(siteCrawlPages.depth), ne2(siteCrawlPages.depth, 0)),
+        ne2(siteCrawlPages.url, scope.rootUrl)
+      )).orderBy(desc6(siteCrawlPages.linkScoreNormalized), asc(siteCrawlPages.nodeKey)).limit(SITE_CRAWL_GRAPH_MAX_NODES - retainedRows.length).all());
+    }
+    assertNotAborted();
+    const nodes = retainedRows.map((row, sampleRank) => ({
+      nodeKey: row.nodeKey,
+      path: row.path,
+      depth: row.depth,
+      sampleRank
+    }));
+    const rootNodeKey = rootRows[0]?.nodeKey ?? null;
+    const priorPositions = loadPriorSiteCrawlGraphPositions(db, scope);
+    assertNotAborted();
+    const selectedKeys = JSON.stringify(nodes.map((node) => node.nodeKey));
+    const edgeRows = nodes.length === 0 ? [] : db.all(sql5`
+      WITH selected(node_key) AS (SELECT value FROM json_each(${selectedKeys}))
+      SELECT
+        edge.edge_key AS edgeKey,
+        edge.source_node_key AS sourceNodeKey,
+        edge.target_node_key AS targetNodeKey,
+        edge.followable AS followable,
+        edge.occurrences AS occurrences
+      FROM site_crawl_edges AS edge
+      INNER JOIN selected AS source ON source.node_key = edge.source_node_key
+      INNER JOIN selected AS target ON target.node_key = edge.target_node_key
+      WHERE edge.project_id = ${scope.projectId}
+        AND edge.run_id = ${scope.runId}
+        AND edge.attempt_id = ${scope.attemptId}
+        AND edge.internal = 1
+        AND edge.relation = 'anchor'
+      ORDER BY edge.occurrences DESC, edge.edge_key ASC
+      LIMIT ${SITE_CRAWL_GRAPH_MAX_EDGES}
+    `);
+    assertNotAborted();
+    return await layoutSiteCrawlGraphInput({
+      totalNodes,
+      totalEdges,
+      nodes,
+      edges: edgeRows,
+      rootNodeKey,
+      priorPositions
+    }, options);
+  } catch (error) {
+    if (options.signal?.aborted) options.signal.throwIfAborted();
+    if (error instanceof DOMException && error.name === "AbortError") throw error;
+    return {
+      state: "unavailable",
+      failureCode: "layout-error",
+      totalNodes,
+      totalEdges,
+      nodeCount: 0,
+      edgeCount: 0,
+      nodes: [],
+      edges: []
+    };
+  }
+}
+function persistSiteCrawlGraphLayout(db, scope, layout, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  db.transaction((tx) => {
+    tx.delete(siteCrawlGraphLayouts).where(and10(
+      eq13(siteCrawlGraphLayouts.projectId, scope.projectId),
+      eq13(siteCrawlGraphLayouts.runId, scope.runId),
+      eq13(siteCrawlGraphLayouts.attemptId, scope.attemptId)
+    )).run();
+    tx.insert(siteCrawlGraphLayouts).values({
+      id: crypto16.randomUUID(),
+      projectId: scope.projectId,
+      runId: scope.runId,
+      attemptId: scope.attemptId,
+      state: layout.state,
+      layoutVersion: layout.state === "ready" ? layout.layoutVersion : null,
+      failureCode: layout.state === "unavailable" ? layout.failureCode : null,
+      totalNodes: layout.totalNodes,
+      totalEdges: layout.totalEdges,
+      nodeCount: layout.nodeCount,
+      edgeCount: layout.edgeCount,
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    if (layout.state !== "ready") return;
+    const batchSize = 250;
+    for (let offset = 0; offset < layout.nodes.length; offset += batchSize) {
+      tx.insert(siteCrawlGraphNodes).values(layout.nodes.slice(offset, offset + batchSize).map((node) => ({
+        id: crypto16.randomUUID(),
+        projectId: scope.projectId,
+        runId: scope.runId,
+        attemptId: scope.attemptId,
+        nodeKey: node.nodeKey,
+        sampleRank: node.sampleRank,
+        x: node.x,
+        y: node.y,
+        createdAt: now
+      }))).run();
+    }
+    for (let offset = 0; offset < layout.edges.length; offset += batchSize) {
+      tx.insert(siteCrawlGraphEdges).values(layout.edges.slice(offset, offset + batchSize).map((edge) => ({
+        id: crypto16.randomUUID(),
+        projectId: scope.projectId,
+        runId: scope.runId,
+        attemptId: scope.attemptId,
+        edgeKey: edge.edgeKey,
+        sampleRank: edge.sampleRank,
+        sourceNodeKey: edge.sourceNodeKey,
+        targetNodeKey: edge.targetNodeKey,
+        followable: edge.followable,
+        occurrences: edge.occurrences,
+        createdAt: now
+      }))).run();
+    }
+  });
+}
+function deleteSiteCrawlGraphLayout(db, scope) {
+  db.delete(siteCrawlGraphLayouts).where(and10(
+    eq13(siteCrawlGraphLayouts.projectId, scope.projectId),
+    eq13(siteCrawlGraphLayouts.runId, scope.runId),
+    eq13(siteCrawlGraphLayouts.attemptId, scope.attemptId)
+  )).run();
+}
+
+// src/execute-site-audit.ts
 var log12 = createLogger("SiteAudit");
-var SITE_AUDIT_DEFAULT_PAGE_LIMIT = 500;
-var SITE_AUDIT_MAX_PAGE_LIMIT = 2e3;
+var SiteAuditCancelledError = class extends Error {
+  name = "SiteAuditCancelledError";
+};
 function toHomepageUrl(canonicalDomain) {
   const trimmed = canonicalDomain.trim().replace(/\/+$/, "");
   return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
 }
 async function assertSiteAuditUrlAllowed(rawUrl, field) {
   const check = await resolveWebhookTarget(rawUrl);
-  if (!check.ok) {
-    throw new Error(`${field} ${check.message.replace(/^"url" /, "")}`);
-  }
+  if (!check.ok) throw new Error(`${field} ${check.message.replace(/^"url" /, "")}`);
 }
 function clampSiteAuditLimit(limit) {
   if (limit == null || !Number.isFinite(limit)) return SITE_AUDIT_DEFAULT_PAGE_LIMIT;
   return Math.max(1, Math.min(SITE_AUDIT_MAX_PAGE_LIMIT, Math.floor(limit)));
 }
+function clampSiteAuditEdgeLimit(limit) {
+  if (limit == null || !Number.isFinite(limit)) return SITE_AUDIT_DEFAULT_EDGE_LIMIT;
+  return Math.max(1, Math.min(SITE_AUDIT_MAX_EDGE_LIMIT, Math.floor(limit)));
+}
 function toPageFactor(factor) {
+  return { id: factor.id, name: factor.name, weight: factor.weight, score: factor.score };
+}
+function toCrawlAuditFactor(factor) {
   return {
-    id: factor.id,
-    name: factor.name,
-    weight: factor.weight,
-    score: factor.score
+    ...toPageFactor(factor),
+    status: factorStatusFromScore(factor.score),
+    applicable: factor.applicable ?? null,
+    findings: factor.findings,
+    recommendations: factor.recommendations
+  };
+}
+function crawlAuditFields(audit) {
+  return {
+    schemaVersion: "1.0",
+    factors: audit.factors.map(toCrawlAuditFactor),
+    criticalDefects: audit.criticalDefects
   };
 }
 function computeFactorAverages(pages) {
   const byId = /* @__PURE__ */ new Map();
   for (const page of pages) {
-    if (page.status !== "success" || !page.factors) continue;
-    for (const factor of page.factors) {
-      let entry = byId.get(factor.id);
-      if (!entry) {
-        entry = { name: factor.name, weight: factor.weight, scores: [], pass: 0, partial: 0, fail: 0 };
-        byId.set(factor.id, entry);
-      }
-      entry.scores.push(factor.score);
+    if (!page.audit) continue;
+    for (const factor of page.audit.factors) {
+      const current = byId.get(factor.id) ?? { name: factor.name, weight: factor.weight, scores: [], pass: 0, partial: 0, fail: 0 };
+      byId.set(factor.id, current);
+      current.scores.push(factor.score);
       const status = factorStatusFromScore(factor.score);
-      if (status === "pass") entry.pass++;
-      else if (status === "partial") entry.partial++;
-      else entry.fail++;
+      if (status === "pass") current.pass++;
+      else if (status === "partial") current.partial++;
+      else current.fail++;
     }
   }
-  const summaries = [];
-  for (const [id, entry] of byId) {
-    const avgScore = entry.scores.length ? Math.round(entry.scores.reduce((sum, score) => sum + score, 0) / entry.scores.length) : 0;
-    summaries.push({
+  return [...byId.entries()].map(([id, value]) => {
+    const avgScore = Math.round(value.scores.reduce((sum, score) => sum + score, 0) / value.scores.length);
+    return {
       id,
-      name: entry.name,
-      weight: entry.weight,
+      name: value.name,
+      weight: value.weight,
       avgScore,
       status: factorStatusFromScore(avgScore),
-      pagesPassing: entry.pass,
-      pagesPartial: entry.partial,
-      pagesFailing: entry.fail
-    });
+      pagesPassing: value.pass,
+      pagesPartial: value.partial,
+      pagesFailing: value.fail
+    };
+  }).sort((a, b) => b.weight - a.weight || a.name.localeCompare(b.name));
+}
+function pagePath(page) {
+  if (page.path) return page.path;
+  try {
+    return new URL(page.finalUrl ?? page.requestedUrl).pathname || "/";
+  } catch {
+    return "/";
+  }
+}
+function parentPath(page) {
+  const path10 = pagePath(page);
+  if (path10 === "/") return "/";
+  const trimmed = path10.endsWith("/") ? path10.slice(0, -1) : path10;
+  const slash = trimmed.lastIndexOf("/");
+  return slash <= 0 ? "/" : trimmed.slice(0, slash) || "/";
+}
+function pageDiscoverySource(page) {
+  if (page.provenance.root) return "root";
+  if (page.provenance.sitemapSources.length > 0) return "sitemap";
+  return "link";
+}
+function pageAuditState(page) {
+  if (page.audit) return "success";
+  if (page.state === "fetch-error") return "error";
+  return "not-applicable";
+}
+function isInventoryEligible(page) {
+  return page.state === "html" && page.indexability.state === "indexable";
+}
+function isCancelled(error, signal) {
+  if (error instanceof SiteAuditCancelledError) return true;
+  if (signal?.aborted && signal.reason !== void 0 && error === signal.reason) return true;
+  return error instanceof DOMException && error.name === "AbortError";
+}
+function isLegacyScorecardPage(page) {
+  return page.audit != null || page.state === "fetch-error";
+}
+function emptyCompleteCrawlError(rootUrl, finalRootUrl, pagesObserved) {
+  if (!finalRootUrl) return new Error(`Site audit could not successfully audit any of ${pagesObserved} observed page(s).`);
+  try {
+    const rootHost = new URL(rootUrl).hostname;
+    const finalRootHost = new URL(finalRootUrl).hostname;
+    if (rootHost !== finalRootHost) {
+      return new Error(
+        `Site audit could not successfully audit any of ${pagesObserved} observed page(s): root URL redirected off-host from ${rootHost} to ${finalRootHost} (${finalRootUrl}).`
+      );
+    }
+  } catch {
   }
-  summaries.sort((a, b) => b.weight - a.weight || a.name.localeCompare(b.name));
-  return summaries;
+  return new Error(`Site audit could not successfully audit any of ${pagesObserved} observed page(s).`);
+}
+function toLegacyIssue(summary, totalPages) {
+  const affected = summary.pagesPartial + summary.pagesFailing;
+  if (affected === 0 || summary.avgScore >= 70) return null;
+  return {
+    factorId: summary.id,
+    factorName: summary.name,
+    avgScore: summary.avgScore,
+    affectedPages: affected,
+    totalPages,
+    affectedPct: totalPages > 0 ? Math.round(affected / totalPages * 100) : 0,
+    topRecommendations: []
+  };
+}
+function observedErrorCount(pages) {
+  let total = 0;
+  for (const page of pages) if (page.state === "fetch-error") total++;
+  return total;
+}
+function deadLinkCheckedCount(edges, pages) {
+  const attemptedUrls = /* @__PURE__ */ new Set();
+  for (const page of pages) {
+    if (page.state === "discovered" || page.state === "robots-blocked") continue;
+    attemptedUrls.add(page.requestedUrl);
+    if (page.finalUrl) attemptedUrls.add(page.finalUrl);
+  }
+  return new Set([...edges].filter((edge) => edge.type === "anchor" && edge.classification === "internal" && attemptedUrls.has(edge.to)).map((edge) => edge.to)).size;
 }
 async function executeSiteAudit(db, runId, projectId, opts = {}) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt }).where(eq13(runs.id, runId)).run();
-  try {
-    const project = db.select().from(projects).where(eq13(projects.id, projectId)).get();
-    if (!project) {
-      throw new Error(`Project not found: ${projectId}`);
+  const claim = db.update(runs).set({ status: "running", startedAt }).where(and11(eq14(runs.id, runId), eq14(runs.projectId, projectId), eq14(runs.status, "queued"))).run();
+  if (claim.changes === 0) return;
+  const attemptNumber = (db.select({ value: sql6`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq14(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
+  const attemptId = crypto17.randomUUID();
+  db.insert(siteCrawlAttempts).values({
+    id: attemptId,
+    projectId,
+    runId,
+    attemptNumber,
+    state: "running",
+    startedAt,
+    createdAt: startedAt,
+    updatedAt: startedAt
+  }).run();
+  const observedPages = /* @__PURE__ */ new Map();
+  const observedEdges = /* @__PURE__ */ new Map();
+  const nodeKeyByUrl = /* @__PURE__ */ new Map();
+  const nodePriorityByUrl = /* @__PURE__ */ new Map();
+  const registerNode = (url, nodeKey, priority, changedUrls) => {
+    const currentPriority = nodePriorityByUrl.get(url);
+    const currentNodeKey = nodeKeyByUrl.get(url);
+    if (currentPriority == null || priority > currentPriority || priority === currentPriority && currentNodeKey != null && nodeKey.localeCompare(currentNodeKey) < 0) {
+      nodePriorityByUrl.set(url, priority);
+      nodeKeyByUrl.set(url, nodeKey);
+      changedUrls.add(url);
     }
+  };
+  const registerPageNode = (page, changedUrls) => {
+    observedPages.set(page.key, page);
+    registerNode(page.requestedUrl, page.key, 2, changedUrls);
+    if (page.finalUrl && page.finalUrl !== page.requestedUrl) registerNode(page.finalUrl, page.key, 1, changedUrls);
+  };
+  const bindReferences = (tx, changedUrls, now) => {
+    for (const url of [...new Set(changedUrls)].sort()) {
+      const nodeKey = nodeKeyByUrl.get(url);
+      if (!nodeKey) continue;
+      const scope = [
+        eq14(siteCrawlEdges.projectId, projectId),
+        eq14(siteCrawlEdges.runId, runId),
+        eq14(siteCrawlEdges.attemptId, attemptId)
+      ];
+      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and11(
+        ...scope,
+        eq14(siteCrawlEdges.sourceUrl, url)
+      )).run();
+      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and11(
+        ...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)
+      )).run();
+    }
+  };
+  const persistPage = (tx, page, now) => {
+    const audit = page.audit;
+    tx.insert(siteCrawlPages).values({
+      id: crypto17.randomUUID(),
+      projectId,
+      runId,
+      attemptId,
+      nodeKey: page.key,
+      url: page.requestedUrl,
+      path: pagePath(page),
+      parentPath: parentPath(page),
+      discoverySource: pageDiscoverySource(page),
+      discoveryProvenance: [{
+        discoveredFrom: page.provenance.discoveredFrom,
+        sitemapSources: page.provenance.sitemapSources,
+        root: page.provenance.root
+      }],
+      sitemapMetadata: { sources: page.provenance.sitemapSources },
+      fetchState: page.state,
+      fetchedAt: page.state === "discovered" || page.state === "robots-blocked" ? null : now,
+      httpStatus: page.statusCode,
+      contentType: page.contentType,
+      finalUrl: page.finalUrl,
+      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,
+      indexabilityState: page.indexability.state,
+      indexabilityReasons: page.indexability.reasons,
+      auditState: pageAuditState(page),
+      auditScore: audit?.overallScore ?? null,
+      auditFields: audit ? crawlAuditFields(audit) : {},
+      inventoryEligible: isInventoryEligible(page),
+      depth: page.depth,
+      inboundUniqueEdges: page.metrics.inbound.uniqueEdges,
+      outboundUniqueEdges: page.metrics.outbound.uniqueEdges,
+      inboundOccurrences: page.metrics.inbound.totalOccurrences,
+      outboundOccurrences: page.metrics.outbound.totalOccurrences,
+      linkScoreRaw: page.metrics.linkScoreRaw,
+      linkScoreNormalized: page.metrics.linkScore,
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: [siteCrawlPages.projectId, siteCrawlPages.runId, siteCrawlPages.attemptId, siteCrawlPages.nodeKey],
+      set: {
+        url: page.requestedUrl,
+        path: pagePath(page),
+        parentPath: parentPath(page),
+        discoverySource: pageDiscoverySource(page),
+        discoveryProvenance: [{ discoveredFrom: page.provenance.discoveredFrom, sitemapSources: page.provenance.sitemapSources, root: page.provenance.root }],
+        sitemapMetadata: { sources: page.provenance.sitemapSources },
+        fetchState: page.state,
+        fetchedAt: page.state === "discovered" || page.state === "robots-blocked" ? null : sql6`coalesce(${siteCrawlPages.fetchedAt}, ${now})`,
+        httpStatus: page.statusCode,
+        contentType: page.contentType,
+        finalUrl: page.finalUrl,
+        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,
+        indexabilityState: page.indexability.state,
+        indexabilityReasons: page.indexability.reasons,
+        auditState: pageAuditState(page),
+        auditScore: audit?.overallScore ?? null,
+        auditFields: audit ? crawlAuditFields(audit) : {},
+        inventoryEligible: isInventoryEligible(page),
+        depth: page.depth,
+        inboundUniqueEdges: page.metrics.inbound.uniqueEdges,
+        outboundUniqueEdges: page.metrics.outbound.uniqueEdges,
+        inboundOccurrences: page.metrics.inbound.totalOccurrences,
+        outboundOccurrences: page.metrics.outbound.totalOccurrences,
+        linkScoreRaw: page.metrics.linkScoreRaw,
+        linkScoreNormalized: page.metrics.linkScore,
+        updatedAt: now
+      }
+    }).run();
+  };
+  const persistPages = (tx, pages, now) => {
+    const changedUrls = /* @__PURE__ */ new Set();
+    for (const page of pages) registerPageNode(page, changedUrls);
+    for (const page of pages) persistPage(tx, page, now);
+    bindReferences(tx, changedUrls, now);
+  };
+  const persistEdge = (tx, edge, now) => {
+    observedEdges.set(edge.key, edge);
+    tx.insert(siteCrawlEdges).values({
+      id: crypto17.randomUUID(),
+      projectId,
+      runId,
+      attemptId,
+      edgeKey: edge.key,
+      sourceNodeKey: nodeKeyByUrl.get(edge.from) ?? edge.from,
+      sourceUrl: edge.from,
+      targetNodeKey: nodeKeyByUrl.get(edge.to) ?? null,
+      targetUrl: edge.to,
+      relation: edge.type,
+      internal: edge.classification === "internal",
+      followable: edge.followableOccurrences > 0,
+      occurrences: edge.totalOccurrences,
+      followableOccurrences: edge.followableOccurrences,
+      nofollowOccurrences: edge.nofollowOccurrences,
+      anchors: edge.anchorSummaries.map((anchor) => anchor.text),
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: [siteCrawlEdges.projectId, siteCrawlEdges.runId, siteCrawlEdges.attemptId, siteCrawlEdges.edgeKey],
+      set: {
+        sourceNodeKey: nodeKeyByUrl.get(edge.from) ?? edge.from,
+        sourceUrl: edge.from,
+        targetNodeKey: nodeKeyByUrl.get(edge.to) ?? null,
+        targetUrl: edge.to,
+        relation: edge.type,
+        internal: edge.classification === "internal",
+        followable: edge.followableOccurrences > 0,
+        occurrences: edge.totalOccurrences,
+        followableOccurrences: edge.followableOccurrences,
+        nofollowOccurrences: edge.nofollowOccurrences,
+        anchors: edge.anchorSummaries.map((anchor) => anchor.text),
+        updatedAt: now
+      }
+    }).run();
+  };
+  const persistMetrics = (tx, key, metrics, now) => {
+    tx.update(siteCrawlPages).set({
+      inboundUniqueEdges: metrics.inbound.uniqueEdges,
+      outboundUniqueEdges: metrics.outbound.uniqueEdges,
+      inboundOccurrences: metrics.inbound.totalOccurrences,
+      outboundOccurrences: metrics.outbound.totalOccurrences,
+      depth: metrics.shortestFollowableAnchorDepth,
+      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)
+    )).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)
+      )).get();
+      if (receipt) {
+        if (receipt.checksum !== event.checksum) {
+          throw new Error(`Crawl checkpoint checksum mismatch for ${event.batchId} (${event.sequence})`);
+        }
+        return;
+      }
+      tx.insert(siteCrawlEventReceipts).values({
+        id: crypto17.randomUUID(),
+        projectId,
+        runId,
+        attemptId,
+        sequence: event.sequence,
+        batchId: event.batchId,
+        checksum: event.checksum,
+        receipt: { type: event.type },
+        createdAt: now
+      }).run();
+      if (event.type === "pages") persistPages(tx, event.rows, now);
+      if (event.type === "edges") for (const edge of event.rows) persistEdge(tx, edge, now);
+      if (event.type === "metrics") for (const metric of event.rows) persistMetrics(tx, metric.key, metric.metrics, now);
+      const progress = event.type === "progress" ? event.progress : event.type === "summary" ? event.summary : null;
+      if (progress) {
+        tx.update(siteCrawlAttempts).set({
+          lastEventSequence: event.sequence,
+          lastEventChecksum: event.checksum,
+          pagesDiscovered: progress.pagesDiscovered,
+          pagesFetched: progress.pagesFetched,
+          pagesEligible: event.type === "summary" ? observedPages.size === 0 ? 0 : [...observedPages.values()].filter(isInventoryEligible).length : sql6`${siteCrawlAttempts.pagesEligible}`,
+          pagesErrored: event.type === "summary" ? observedErrorCount(observedPages.values()) : sql6`${siteCrawlAttempts.pagesErrored}`,
+          edgesDiscovered: progress.edgesObserved,
+          updatedAt: now
+        }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
+      } else {
+        tx.update(siteCrawlAttempts).set({
+          lastEventSequence: event.sequence,
+          lastEventChecksum: event.checksum,
+          updatedAt: now
+        }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
+      }
+    });
+  };
+  try {
+    const project = db.select().from(projects).where(eq14(projects.id, projectId)).get();
+    if (!project) throw new Error(`Project not found: ${projectId}`);
     const homepageUrl = toHomepageUrl(project.canonicalDomain);
-    const limit = clampSiteAuditLimit(opts.limit);
-    log12.info("start", { runId, projectId, homepageUrl, sitemapUrl: opts.sitemapUrl ?? null, limit });
+    const maxPages = clampSiteAuditLimit(opts.maxPages ?? opts.limit);
+    const maxEdges = clampSiteAuditEdgeLimit(opts.maxEdges);
     await assertSiteAuditUrlAllowed(homepageUrl, "canonicalDomain");
     if (opts.sitemapUrl) await assertSiteAuditUrlAllowed(opts.sitemapUrl, "sitemapUrl");
-    const report = await runSitemapAudit(homepageUrl, { sitemapUrl: opts.sitemapUrl, limit });
-    const successCount = report.pages.filter((page) => page.status === "success").length;
-    const pagesErrored = report.pages.filter((page) => page.status === "error").length;
-    const auditable = report.pagesDiscovered - report.pagesSkipped;
-    if (auditable > report.pagesAudited) {
-      log12.info("truncated", {
+    log12.info("start", { runId, projectId, homepageUrl, maxPages, maxEdges, maxDepth: opts.maxDepth ?? null });
+    const report = await runSiteCrawl(homepageUrl, {
+      mode: "summary",
+      sitemapUrl: opts.sitemapUrl,
+      maxPages,
+      maxEdges,
+      maxDepth: opts.maxDepth,
+      checkDeadLinks: opts.checkDeadLinks ?? false,
+      signal: opts.signal,
+      onEvent: persistEvent
+    });
+    const crawlSummary = report.summary;
+    const hasAuditedPages = crawlSummary.auditRollup.auditedPages > 0;
+    if (crawlSummary.complete && !hasAuditedPages) {
+      throw emptyCompleteCrawlError(crawlSummary.rootUrl, crawlSummary.finalRootUrl, crawlSummary.pagesObserved);
+    }
+    const graphLayout = await prepareSiteCrawlGraphLayout(db, {
+      projectId,
+      runId,
+      attemptId,
+      rootUrl: crawlSummary.finalRootUrl ?? crawlSummary.rootUrl
+    }, { signal: opts.signal, timeoutMs: opts.graphLayoutTimeoutMs });
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const factors = computeFactorAverages([...observedPages.values()]);
+    const errorCount = observedErrorCount(observedPages.values());
+    const terminalStatus = crawlSummary.complete ? "completed" : "partial";
+    const deadLinksChecked = opts.checkDeadLinks ? deadLinkCheckedCount(observedEdges.values(), observedPages.values()) : 0;
+    const deadLinksFound = report.deadLinks.findings.length;
+    const legacyIssues = factors.map((factor) => toLegacyIssue(factor, crawlSummary.auditRollup.auditedPages)).filter((issue) => issue !== null);
+    try {
+      persistSiteCrawlGraphLayout(db, { projectId, runId, attemptId }, graphLayout, finishedAt);
+    } catch (error) {
+      log12.warn("graph-layout.persist-failed", {
         runId,
         projectId,
-        auditable,
-        audited: report.pagesAudited,
-        dropped: auditable - report.pagesAudited,
-        limit
+        error: error instanceof Error ? error.message : String(error)
       });
+      try {
+        persistSiteCrawlGraphLayout(db, { projectId, runId, attemptId }, {
+          state: "unavailable",
+          failureCode: "layout-error",
+          totalNodes: graphLayout.totalNodes,
+          totalEdges: graphLayout.totalEdges,
+          nodeCount: 0,
+          edgeCount: 0,
+          nodes: [],
+          edges: []
+        }, finishedAt);
+      } catch (markerError) {
+        log12.warn("graph-layout.marker-persist-failed", {
+          runId,
+          projectId,
+          error: markerError instanceof Error ? markerError.message : String(markerError)
+        });
+      }
     }
-    if (successCount === 0) {
-      throw new Error(
-        `Site audit could not successfully audit any of ${report.pagesAudited} page(s) from ${report.sitemapUrl}.`
-      );
-    }
-    const factorAverages = computeFactorAverages(report.pages);
-    const status = pagesErrored === 0 ? "completed" : "partial";
-    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-    db.transaction((tx) => {
-      tx.insert(siteAuditSnapshots).values({
-        id: crypto16.randomUUID(),
-        projectId,
-        runId,
-        sitemapUrl: report.sitemapUrl,
-        auditedAt: report.auditedAt,
-        aggregateScore: report.aggregateScore,
-        pagesDiscovered: report.pagesDiscovered,
-        pagesAudited: report.pagesAudited,
-        pagesSkipped: report.pagesSkipped,
-        pagesErrored,
-        factorAverages,
-        // aeo-audit v3 enriches these (topIssues, avgGrade-free); keep only the
-        // fields our DTO exposes so the stored JSON stays lean.
-        crossCuttingIssues: report.crossCuttingIssues.map((issue) => ({
-          factorId: issue.factorId,
-          factorName: issue.factorName,
-          avgScore: issue.avgScore,
-          affectedPages: issue.affectedPages,
-          totalPages: issue.totalPages,
-          affectedPct: issue.totalPages > 0 ? Math.round(issue.affectedPages / issue.totalPages * 100) : 0,
-          topRecommendations: issue.topRecommendations
-        })),
-        // v3 prioritizedFixes are structured PrioritizedFix objects; persist the
-        // ready-to-display one-line summary to keep the DTO a string list.
-        prioritizedFixes: report.prioritizedFixes.map((fix) => fix.summary),
-        createdAt: finishedAt
-      }).run();
-      for (const page of report.pages) {
-        tx.insert(siteAuditPages).values({
-          id: crypto16.randomUUID(),
+    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();
+      if (claim2.changes === 0) return false;
+      if (hasAuditedPages) {
+        tx.insert(siteAuditSnapshots).values({
+          id: crypto17.randomUUID(),
           projectId,
           runId,
-          url: page.url,
-          overallScore: page.overallScore,
-          status: page.status,
-          error: page.error ?? null,
-          factors: (page.factors ?? []).map(toPageFactor),
+          sitemapUrl: opts.sitemapUrl ?? `${homepageUrl}/sitemap.xml`,
+          auditedAt: crawlSummary.completedAt,
+          aggregateScore: crawlSummary.auditRollup.aggregateScore ?? 0,
+          pagesDiscovered: crawlSummary.pagesDiscovered,
+          pagesAudited: crawlSummary.auditRollup.auditedPages,
+          pagesSkipped: Math.max(0, crawlSummary.pagesDiscovered - crawlSummary.pagesObserved),
+          pagesErrored: errorCount,
+          factorAverages: factors,
+          crossCuttingIssues: legacyIssues,
+          prioritizedFixes: legacyIssues.map((issue) => `Improve ${issue.factorName}`),
           createdAt: finishedAt
         }).run();
+        for (const page of observedPages.values()) {
+          if (!isLegacyScorecardPage(page)) continue;
+          tx.insert(siteAuditPages).values({
+            id: crypto17.randomUUID(),
+            projectId,
+            runId,
+            url: page.finalUrl ?? page.requestedUrl,
+            overallScore: page.audit?.overallScore ?? 0,
+            status: page.audit ? "success" : "error",
+            error: page.error,
+            factors: page.audit?.factors.map(toPageFactor) ?? [],
+            createdAt: finishedAt
+          }).run();
+        }
       }
-      tx.update(runs).set({ status, finishedAt }).where(eq13(runs.id, runId)).run();
+      tx.insert(siteCrawlSnapshots).values({
+        id: crypto17.randomUUID(),
+        projectId,
+        runId,
+        attemptId,
+        requestedRootUrl: crawlSummary.rootUrl,
+        rootUrl: crawlSummary.finalRootUrl ?? crawlSummary.rootUrl,
+        crawlSchemaVersion: crawlSummary.crawlSchemaVersion,
+        engineVersion: crawlSummary.engineVersion,
+        normalizationVersion: crawlSummary.urlNormalizationVersion,
+        indexabilityVersion: crawlSummary.indexabilityRulesetVersion,
+        linkScoreVersion: crawlSummary.linkScoreAlgorithmVersion,
+        effectiveOptions: {
+          mode: "summary",
+          sitemapUrl: opts.sitemapUrl ?? null,
+          maxPages,
+          maxEdges,
+          maxDepth: opts.maxDepth ?? null,
+          checkDeadLinks: opts.checkDeadLinks ?? false
+        },
+        pageBudget: maxPages,
+        edgeBudget: maxEdges,
+        maxDepth: opts.maxDepth ?? null,
+        checkDeadLinks: opts.checkDeadLinks ?? false,
+        complete: crawlSummary.complete,
+        termination: crawlSummary.terminationReason ?? "complete",
+        detailsAvailable: true,
+        pagesDiscovered: crawlSummary.pagesDiscovered,
+        pagesFetched: crawlSummary.pagesFetched,
+        pagesEligible: [...observedPages.values()].filter(isInventoryEligible).length,
+        pagesErrored: errorCount,
+        edgesDiscovered: crawlSummary.edgesObserved,
+        findingsCount: deadLinksFound,
+        deadLinkState: report.deadLinks.state,
+        deadLinksChecked,
+        deadLinksFound,
+        createdAt: finishedAt,
+        updatedAt: finishedAt
+      }).run();
+      if (opts.checkDeadLinks) {
+        for (const finding of report.deadLinks.findings) {
+          tx.insert(siteCrawlFindings).values({
+            id: crypto17.randomUUID(),
+            projectId,
+            runId,
+            attemptId,
+            findingKey: finding.key,
+            findingType: "dead-link",
+            severity: "error",
+            sourceNodeKey: nodeKeyByUrl.get(finding.from) ?? null,
+            sourceUrl: finding.from,
+            targetNodeKey: nodeKeyByUrl.get(finding.to) ?? null,
+            targetUrl: finding.to,
+            evidence: { statusCode: finding.statusCode, reason: finding.reason },
+            createdAt: finishedAt,
+            updatedAt: finishedAt
+          }).run();
+        }
+      }
+      tx.update(siteCrawlAttempts).set({
+        state: terminalStatus,
+        pagesDiscovered: crawlSummary.pagesDiscovered,
+        pagesFetched: crawlSummary.pagesFetched,
+        pagesEligible: [...observedPages.values()].filter(isInventoryEligible).length,
+        pagesErrored: errorCount,
+        edgesDiscovered: crawlSummary.edgesObserved,
+        finishedAt,
+        updatedAt: finishedAt
+      }).where(eq14(siteCrawlAttempts.id, attemptId)).run();
+      return true;
     });
-    log12.info("completed", {
-      runId,
-      projectId,
-      status,
-      score: report.aggregateScore,
-      audited: report.pagesAudited,
-      errored: pagesErrored
+    if (!published) {
+      try {
+        deleteSiteCrawlGraphLayout(db, { projectId, runId, attemptId });
+      } catch (cleanupError) {
+        log12.warn("graph-layout.cleanup-failed", {
+          runId,
+          projectId,
+          error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+        });
+      }
+      const current = db.select({ status: runs.status }).from(runs).where(eq14(runs.id, runId)).get();
+      if (current?.status === "cancelled") throw new SiteAuditCancelledError(`Site audit cancelled before publication: ${runId}`);
+      throw new Error(`Site audit run was no longer running before publication: ${runId}`);
+    }
+    log12.info("completed", { runId, projectId, status: terminalStatus, complete: crawlSummary.complete, pages: crawlSummary.pagesObserved });
+  } catch (error) {
+    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const cancelled = isCancelled(error, opts.signal);
+    const message = error instanceof Error ? error.message : String(error);
+    db.transaction((tx) => {
+      tx.update(siteCrawlAttempts).set({
+        state: cancelled ? "cancelled" : "failed",
+        error: message,
+        finishedAt,
+        updatedAt: finishedAt
+      }).where(eq14(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();
     });
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq13(runs.id, runId)).run();
-    log12.error("failed", { runId, projectId, error: errorMsg });
-    throw err;
+    log12.error("failed", { runId, projectId, cancelled, error: message });
+    throw error;
   }
 }
 
 // src/commands/backfill.ts
-import { and as and10, eq as eq14, inArray as inArray4, isNull, sql as sql5 } from "drizzle-orm";
+import { and as and12, eq as eq15, inArray as inArray4, isNull as isNull2, sql as sql7 } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
@@ -7060,7 +7957,7 @@ async function backfillAnswerVisibilityCommand(opts) {
   migrate(db);
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -7068,10 +7965,10 @@ async function backfillAnswerVisibilityCommand(opts) {
   let reparsed = 0;
   let providerErrors = 0;
   if (scopedProjects.length > 0) {
-    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and10(
-      eq14(runs.kind, RunKinds["answer-visibility"]),
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and12(
+      eq15(runs.kind, RunKinds["answer-visibility"]),
       inArray4(runs.projectId, scopedProjects.map((project) => project.id))
-    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq14(runs.kind, RunKinds["answer-visibility"])).all();
+    )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq15(runs.kind, RunKinds["answer-visibility"])).all();
     const runIdsByProject = /* @__PURE__ */ new Map();
     for (const run of runRows) {
       const existing = runIdsByProject.get(run.projectId);
@@ -7079,7 +7976,7 @@ async function backfillAnswerVisibilityCommand(opts) {
       else runIdsByProject.set(run.projectId, [run.id]);
     }
     for (const project of scopedProjects) {
-      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq14(competitors.projectId, project.id)).all().map((row) => row.domain);
+      const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq15(competitors.projectId, project.id)).all().map((row) => row.domain);
       const runIds = runIdsByProject.get(project.id) ?? [];
       if (runIds.length === 0) continue;
       const projectDomains = effectiveDomains({
@@ -7172,7 +8069,7 @@ async function backfillAnswerVisibilityCommand(opts) {
           } else {
             db.transaction((tx) => {
               for (const update of pendingUpdates) {
-                tx.update(querySnapshots).set(update.patch).where(eq14(querySnapshots.id, update.id)).run();
+                tx.update(querySnapshots).set(update.patch).where(eq15(querySnapshots.id, update.id)).run();
               }
             });
             updated += pendingUpdates.length;
@@ -7221,13 +8118,13 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 function backfillNormalizedPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq14(gaTrafficSnapshots.projectId, opts.projectId));
+    baseConditions.push(eq15(gaTrafficSnapshots.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaTrafficSnapshots.id,
     landingPage: gaTrafficSnapshots.landingPage,
     landingPageNormalized: gaTrafficSnapshots.landingPageNormalized
-  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
+  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and12(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -7242,7 +8139,7 @@ function backfillNormalizedPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq14(gaTrafficSnapshots.id, row.id)).run();
+        tx.update(gaTrafficSnapshots).set({ landingPageNormalized: next }).where(eq15(gaTrafficSnapshots.id, row.id)).run();
         updated++;
       }
     });
@@ -7256,7 +8153,7 @@ async function backfillNormalizedPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq14(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq15(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -7293,13 +8190,13 @@ async function backfillNormalizedPathsCommand(opts) {
 function backfillAiReferralPaths(db, opts) {
   const baseConditions = [];
   if (opts?.projectId) {
-    baseConditions.push(eq14(gaAiReferrals.projectId, opts.projectId));
+    baseConditions.push(eq15(gaAiReferrals.projectId, opts.projectId));
   }
   const rows = db.select({
     id: gaAiReferrals.id,
     landingPage: gaAiReferrals.landingPage,
     landingPageNormalized: gaAiReferrals.landingPageNormalized
-  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
+  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and12(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -7314,7 +8211,7 @@ function backfillAiReferralPaths(db, opts) {
           unchanged++;
           continue;
         }
-        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq14(gaAiReferrals.id, row.id)).run();
+        tx.update(gaAiReferrals).set({ landingPageNormalized: next }).where(eq15(gaAiReferrals.id, row.id)).run();
         updated++;
       }
     });
@@ -7328,7 +8225,7 @@ async function backfillAiReferralPathsCommand(opts) {
   const projectFilter = opts?.project?.trim();
   let projectId;
   if (projectFilter) {
-    const project = db.select({ id: projects.id }).from(projects).where(eq14(projects.name, projectFilter)).get();
+    const project = db.select({ id: projects.id }).from(projects).where(eq15(projects.name, projectFilter)).get();
     if (!project) {
       const result2 = {
         project: projectFilter,
@@ -7364,10 +8261,10 @@ async function backfillAiReferralPathsCommand(opts) {
 }
 function backfillProjectAnswerMentions(db, projectId, opts) {
   const isDryRun = opts?.dryRun === true;
-  const project = db.select().from(projects).where(eq14(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq15(projects.id, projectId)).get();
   if (!project) return { examined: 0, updated: 0, mentioned: 0 };
-  const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq14(competitors.projectId, projectId)).all().map((row) => row.domain);
-  const runRows = db.select({ id: runs.id }).from(runs).where(and10(eq14(runs.kind, RunKinds["answer-visibility"]), eq14(runs.projectId, projectId))).all();
+  const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq15(competitors.projectId, projectId)).all().map((row) => row.domain);
+  const runRows = db.select({ id: runs.id }).from(runs).where(and12(eq15(runs.kind, RunKinds["answer-visibility"]), eq15(runs.projectId, projectId))).all();
   const runIds = runRows.map((r) => r.id);
   let examined = 0;
   let updated = 0;
@@ -7441,7 +8338,7 @@ function backfillProjectAnswerMentions(db, projectId, opts) {
       } else {
         db.transaction((tx) => {
           for (const update of pendingUpdates) {
-            tx.update(querySnapshots).set(update.patch).where(eq14(querySnapshots.id, update.id)).run();
+            tx.update(querySnapshots).set(update.patch).where(eq15(querySnapshots.id, update.id)).run();
           }
         });
         updated += pendingUpdates.length;
@@ -7456,7 +8353,7 @@ async function backfillAnswerMentionsCommand(opts) {
   migrate(db);
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
   let examined = 0;
   let updated = 0;
   let wouldUpdate = 0;
@@ -7516,7 +8413,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-ZY5KOSZV.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-WHC7B32V.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -7675,7 +8572,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
-  const project = db.select().from(projects).where(eq14(projects.name, opts.project)).get();
+  const project = db.select().from(projects).where(eq15(projects.name, opts.project)).get();
   if (!project) {
     throw new Error(`Project "${opts.project}" not found`);
   }
@@ -7686,8 +8583,8 @@ async function backfillSnapshotAttributionCommand(opts) {
     process.stderr.write(`Recovering orphan snapshot attribution for "${project.name}"${mode}...
 `);
   }
-  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and10(
-    eq14(auditLog.projectId, project.id),
+  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and12(
+    eq15(auditLog.projectId, project.id),
     inArray4(auditLog.action, ["keywords.appended", "keywords.deleted", "queries.appended", "queries.deleted", "queries.replaced"])
   )).orderBy(auditLog.createdAt).all();
   const history = replayQueryAuditLog(events);
@@ -7695,10 +8592,10 @@ async function backfillSnapshotAttributionCommand(opts) {
     runId: runs.id,
     createdAt: runs.createdAt,
     location: runs.location
-  }).from(runs).innerJoin(querySnapshots, eq14(querySnapshots.runId, runs.id)).where(and10(
-    eq14(runs.projectId, project.id),
-    isNull(querySnapshots.queryId),
-    isNull(querySnapshots.queryText)
+  }).from(runs).innerJoin(querySnapshots, eq15(querySnapshots.runId, runs.id)).where(and12(
+    eq15(runs.projectId, project.id),
+    isNull2(querySnapshots.queryId),
+    isNull2(querySnapshots.queryText)
   )).groupBy(runs.id).orderBy(runs.createdAt).all();
   const result = {
     project: project.name,
@@ -7718,10 +8615,10 @@ async function backfillSnapshotAttributionCommand(opts) {
       provider: querySnapshots.provider,
       createdAt: querySnapshots.createdAt,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).where(and10(
-      eq14(querySnapshots.runId, run.runId),
-      isNull(querySnapshots.queryId),
-      isNull(querySnapshots.queryText)
+    }).from(querySnapshots).where(and12(
+      eq15(querySnapshots.runId, run.runId),
+      isNull2(querySnapshots.queryId),
+      isNull2(querySnapshots.queryText)
     )).orderBy(querySnapshots.provider, querySnapshots.createdAt).all();
     const byProvider = /* @__PURE__ */ new Map();
     for (const s of orphanSnaps) {
@@ -7785,7 +8682,7 @@ async function backfillSnapshotAttributionCommand(opts) {
   if (!isDryRun && updates.length > 0) {
     db.transaction((tx) => {
       for (const u of updates) {
-        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq14(querySnapshots.id, u.id)).run();
+        tx.update(querySnapshots).set({ queryText: u.queryText }).where(eq15(querySnapshots.id, u.id)).run();
       }
     });
   }
@@ -7859,7 +8756,7 @@ async function backfillTrafficClassificationCommand(opts) {
   const projectFilter = opts?.project?.trim();
   const isDryRun = opts?.dryRun === true;
   const isJson = isMachineFormat(opts?.format);
-  const scopedProjects = projectFilter ? db.select().from(projects).where(eq14(projects.name, projectFilter)).all() : db.select().from(projects).all();
+  const scopedProjects = projectFilter ? db.select().from(projects).where(eq15(projects.name, projectFilter)).all() : db.select().from(projects).all();
   if (scopedProjects.length === 0) {
     if (projectFilter && !isJson) {
       process.stderr.write(`No project named "${projectFilter}".
@@ -7884,8 +8781,8 @@ async function backfillTrafficClassificationCommand(opts) {
     dryRun: isDryRun,
     byBot: {}
   };
-  const unknownCountRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and10(
-    eq14(rawEventSamples.eventType, "unknown"),
+  const unknownCountRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and12(
+    eq15(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).get();
   result.unknownBefore = Number(unknownCountRow?.n ?? 0);
@@ -7897,8 +8794,8 @@ async function backfillTrafficClassificationCommand(opts) {
     userAgent: rawEventSamples.userAgent,
     pathNormalized: rawEventSamples.pathNormalized,
     status: rawEventSamples.status
-  }).from(rawEventSamples).where(and10(
-    eq14(rawEventSamples.eventType, "unknown"),
+  }).from(rawEventSamples).where(and12(
+    eq15(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).all();
   result.examined = unknownSamples.length;
@@ -7937,7 +8834,7 @@ async function backfillTrafficClassificationCommand(opts) {
     result.reclassified++;
     result.byBot[classified.botId] = (result.byBot[classified.botId] ?? 0) + 1;
     if (isDryRun) continue;
-    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq14(rawEventSamples.id, snap.id)).run();
+    db.update(rawEventSamples).set({ eventType: userFetch ? TrafficEventKinds["ai-user-fetch"] : TrafficEventKinds.crawler }).where(eq15(rawEventSamples.id, snap.id)).run();
     const tsHour = new Date(snap.ts);
     tsHour.setUTCMinutes(0, 0, 0);
     if (userFetch) {
@@ -7965,7 +8862,7 @@ async function backfillTrafficClassificationCommand(opts) {
           aiUserFetchEventsHourly.status
         ],
         set: {
-          hits: sql5`${aiUserFetchEventsHourly.hits} + 1`,
+          hits: sql7`${aiUserFetchEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
@@ -7994,15 +8891,15 @@ async function backfillTrafficClassificationCommand(opts) {
           crawlerEventsHourly.status
         ],
         set: {
-          hits: sql5`${crawlerEventsHourly.hits} + 1`,
+          hits: sql7`${crawlerEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
     }
   }
   if (!isDryRun) {
-    const afterRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and10(
-      eq14(rawEventSamples.eventType, "unknown"),
+    const afterRow = db.select({ n: sql7`count(*)` }).from(rawEventSamples).where(and12(
+      eq15(rawEventSamples.eventType, "unknown"),
       inArray4(rawEventSamples.projectId, projectIds)
     )).get();
     result.unknownAfter = Number(afterRow?.n ?? 0);
@@ -8026,8 +8923,8 @@ Traffic classification ${result.dryRun ? "preview" : "recovery"} complete.`);
   if (result.reclassified > 0) {
     console.log(`  By bot:`);
     const sorted = Object.entries(result.byBot).sort(([, a], [, b]) => b - a);
-    for (const [bot, count] of sorted) {
-      console.log(`    ${count.toString().padStart(5)}  ${bot}`);
+    for (const [bot, count2] of sorted) {
+      console.log(`    ${count2.toString().padStart(5)}  ${bot}`);
     }
   }
   if (result.dryRun) {
@@ -8037,7 +8934,7 @@ No DB writes performed. Re-run without --dry-run to apply.`);
 }
 
 // src/commands/skills.ts
-import crypto17 from "crypto";
+import crypto18 from "crypto";
 import fs4 from "fs";
 import os4 from "os";
 import path5 from "path";
@@ -8092,7 +8989,7 @@ function walkRelative(dir, prefix = "") {
   return out.sort();
 }
 function sha256File(filePath) {
-  return crypto17.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
+  return crypto18.createHash("sha256").update(fs4.readFileSync(filePath)).digest("hex");
 }
 function readSkillManifest(skillDir) {
   try {
@@ -8434,9 +9331,9 @@ var ProviderRegistry = class {
 };
 
 // src/scheduler.ts
-import crypto18 from "crypto";
+import crypto19 from "crypto";
 import cron from "node-cron";
-import { and as and11, eq as eq15, inArray as inArray5, notExists, sql as sql6 } from "drizzle-orm";
+import { and as and13, eq as eq16, inArray as inArray5, notExists, sql as sql8 } from "drizzle-orm";
 var log13 = createLogger("Scheduler");
 var DEFAULT_HEALTH_CRON = "0 */6 * * *";
 function taskKey(projectId, kind) {
@@ -8468,16 +9365,16 @@ var Scheduler = class {
    */
   ensureHealthSchedules() {
     const projectsWithoutHealth = this.db.select({ id: projects.id }).from(projects).where(notExists(
-      this.db.select({ one: sql6`1` }).from(schedules).where(and11(
-        eq15(schedules.projectId, projects.id),
-        eq15(schedules.kind, SchedulableRunKinds.doctor)
+      this.db.select({ one: sql8`1` }).from(schedules).where(and13(
+        eq16(schedules.projectId, projects.id),
+        eq16(schedules.kind, SchedulableRunKinds.doctor)
       ))
     )).all();
     if (projectsWithoutHealth.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const project of projectsWithoutHealth) {
       this.db.insert(schedules).values({
-        id: crypto18.randomUUID(),
+        id: crypto19.randomUUID(),
         projectId: project.id,
         kind: SchedulableRunKinds.doctor,
         cronExpr: DEFAULT_HEALTH_CRON,
@@ -8521,7 +9418,7 @@ var Scheduler = class {
   start() {
     this.ensureHealthSchedules();
     this.ensureQueryBaskets();
-    const allSchedules = this.db.select().from(schedules).where(eq15(schedules.enabled, true)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq16(schedules.enabled, true)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
@@ -8551,7 +9448,7 @@ var Scheduler = class {
       this.stopTask(key, existing, "Stopped");
       this.tasks.delete(key);
     }
-    const schedule = this.db.select().from(schedules).where(and11(eq15(schedules.projectId, projectId), eq15(schedules.kind, kind))).get();
+    const schedule = this.db.select().from(schedules).where(and13(eq16(schedules.projectId, projectId), eq16(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -8592,21 +9489,21 @@ var Scheduler = class {
     this.db.update(schedules).set({
       nextRunAt: nextRunFromCron(cronExpr, timezone),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq15(schedules.id, scheduleId)).run();
+    }).where(eq16(schedules.id, scheduleId)).run();
     const label = schedule.preset ?? cronExpr;
     log13.info("cron.registered", { projectId, kind, schedule: label, timezone });
   }
   triggerRun(scheduleId, projectId, kind) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const currentSchedule = this.db.select().from(schedules).where(eq15(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq16(schedules.id, scheduleId)).get();
       if (!currentSchedule || !currentSchedule.enabled) {
         log13.warn("schedule.stale", { scheduleId, projectId, kind, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId, kind);
         return;
       }
       const nextRunAt = nextRunFromCron(currentSchedule.cronExpr, currentSchedule.timezone);
-      const project = this.db.select().from(projects).where(eq15(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
       if (!project) {
         log13.error("project.not-found", { projectId, kind, msg: "skipping scheduled run" });
         this.remove(projectId, kind);
@@ -8626,7 +9523,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("traffic-sync.triggered", { projectName: project.name, sourceId });
         this.callbacks.onTrafficSyncRequested(project.name, sourceId);
         return;
@@ -8636,7 +9533,7 @@ var Scheduler = class {
           log13.warn("gbp-sync.no-callback", { scheduleId, projectId, msg: "host did not register onGbpSyncRequested" });
           return;
         }
-        const runId2 = crypto18.randomUUID();
+        const runId2 = crypto19.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -8649,7 +9546,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("gbp-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onGbpSyncRequested(runId2, projectId);
         return;
@@ -8659,17 +9556,17 @@ var Scheduler = class {
           log13.warn("ads-sync.no-callback", { scheduleId, projectId, msg: "host did not register onAdsSyncRequested" });
           return;
         }
-        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and11(
-          eq15(runs.projectId, projectId),
-          eq15(runs.kind, RunKinds["ads-sync"]),
+        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and13(
+          eq16(runs.projectId, projectId),
+          eq16(runs.kind, RunKinds["ads-sync"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (activeAdsRun) {
           log13.info("ads-sync.skipped-active", { projectName: project.name, activeRunId: activeAdsRun.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq15(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq16(schedules.id, currentSchedule.id)).run();
           return;
         }
-        const runId2 = crypto18.randomUUID();
+        const runId2 = crypto19.randomUUID();
         this.db.insert(runs).values({
           id: runId2,
           projectId,
@@ -8682,7 +9579,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("ads-sync.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onAdsSyncRequested(runId2, projectId);
         return;
@@ -8696,7 +9593,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("data-refresh.triggered", { projectName: project.name });
         this.callbacks.onDataRefreshRequested(project.name);
         return;
@@ -8710,7 +9607,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("doctor.triggered", { projectName: project.name });
         this.callbacks.onDoctorRequested(project.name);
         return;
@@ -8724,7 +9621,7 @@ var Scheduler = class {
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("backlinks-sync.triggered", { projectName: project.name });
         this.callbacks.onBacklinksSyncRequested(project.name);
         return;
@@ -8734,30 +9631,40 @@ 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(and11(
-          eq15(runs.projectId, projectId),
-          eq15(runs.kind, RunKinds["site-audit"]),
+        const active = this.db.select({ id: runs.id }).from(runs).where(and13(
+          eq16(runs.projectId, projectId),
+          eq16(runs.kind, RunKinds["site-audit"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
         )).get();
         if (active) {
           log13.info("site-audit.skipped-active", { projectName: project.name, activeRunId: active.id });
-          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq15(schedules.id, currentSchedule.id)).run();
+          this.db.update(schedules).set({ nextRunAt, updatedAt: now }).where(eq16(schedules.id, currentSchedule.id)).run();
           return;
         }
-        const runId2 = crypto18.randomUUID();
-        this.db.insert(runs).values({
-          id: runId2,
-          projectId,
-          kind: RunKinds["site-audit"],
-          status: RunStatuses.queued,
-          trigger: RunTriggers.scheduled,
-          createdAt: now
-        }).run();
+        const runId2 = crypto19.randomUUID();
+        const effectiveRequest = normalizeSiteAuditRunRequest({});
+        this.db.transaction((tx) => {
+          tx.insert(runs).values({
+            id: runId2,
+            projectId,
+            kind: RunKinds["site-audit"],
+            status: RunStatuses.queued,
+            trigger: RunTriggers.scheduled,
+            createdAt: now
+          }).run();
+          tx.insert(siteCrawlRunRequests).values({
+            runId: runId2,
+            projectId,
+            identityKey: siteAuditRequestIdentity(effectiveRequest),
+            effectiveOptions: effectiveRequest,
+            createdAt: now
+          }).run();
+        });
         this.db.update(schedules).set({
           lastRunAt: now,
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         log13.info("site-audit.triggered", { runId: runId2, projectName: project.name });
         this.callbacks.onSiteAuditRequested(runId2, projectId);
         return;
@@ -8790,7 +9697,7 @@ var Scheduler = class {
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
-        }).where(eq15(schedules.id, currentSchedule.id)).run();
+        }).where(eq16(schedules.id, currentSchedule.id)).run();
         return;
       }
       const runId = queueResult.runId;
@@ -8798,7 +9705,7 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq15(schedules.id, currentSchedule.id)).run();
+      }).where(eq16(schedules.id, currentSchedule.id)).run();
       log13.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
       this.callbacks.onRunCreated(runId, projectId, providers, resolvedLocation);
     } catch (err) {
@@ -8831,8 +9738,8 @@ async function refreshAllIntegrations(client, projectName) {
 }
 
 // src/notifier.ts
-import { eq as eq16, desc as desc6, and as and12, inArray as inArray6, or } from "drizzle-orm";
-import crypto19 from "crypto";
+import { eq as eq17, desc as desc7, and as and14, inArray as inArray6, or as or2 } from "drizzle-orm";
+import crypto20 from "crypto";
 var log15 = createLogger("Notifier");
 var Notifier = class {
   db;
@@ -8844,18 +9751,18 @@ var Notifier = class {
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
     log15.info("run.completed", { runId, projectId });
-    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) {
       log15.info("notifications.none-enabled", { projectId });
       return;
     }
     log15.info("notifications.found", { projectId, count: notifs.length });
-    const run = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
     if (!run) {
       log15.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
-    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
@@ -8908,7 +9815,7 @@ var Notifier = class {
    * inferred from the absence of a webhook.
    */
   async onHealthChecked(projectId, report) {
-    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
     if (!project) {
       log15.error("project.not-found", { projectId, msg: "skipping health notification" });
       return null;
@@ -8939,7 +9846,7 @@ var Notifier = class {
     const status = noSignal ? "warn" : worst ? worst.status : "ok";
     const code = noSignal ? "health.no-signal" : worst?.code ?? "health.ok";
     const summary = noSignal ? `No health check produced a result (${report.checks.length} skipped) \u2014 health is unknown, not confirmed.` : worst?.summary ?? `All ${graded.length} health check(s) passing.`;
-    const previous = this.db.select().from(doctorHealthState).where(eq16(doctorHealthState.projectId, projectId)).get();
+    const previous = this.db.select().from(doctorHealthState).where(eq17(doctorHealthState.projectId, projectId)).get();
     const previousStatus = previous?.status ?? null;
     let event = null;
     if (previous === void 0) {
@@ -8954,13 +9861,13 @@ var Notifier = class {
     if (previous === void 0) {
       this.db.insert(doctorHealthState).values({ ...observation, notifiedAt: null }).run();
     } else {
-      this.db.update(doctorHealthState).set(observation).where(eq16(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set(observation).where(eq17(doctorHealthState.projectId, projectId)).run();
     }
     if (!event) {
       log15.info("health.unchanged", { projectId, status, code });
       return null;
     }
-    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     const payload = {
       source: "canonry",
       event,
@@ -8984,7 +9891,7 @@ var Notifier = class {
       delivered += 1;
     }
     if (delivered > 0) {
-      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq16(doctorHealthState.projectId, projectId)).run();
+      this.db.update(doctorHealthState).set({ notifiedAt: now }).where(eq17(doctorHealthState.projectId, projectId)).run();
     }
     log15.info("health.notified", { projectId, event, status, code, subscribers: notifs.length, delivered });
     return event;
@@ -8997,11 +9904,11 @@ var Notifier = class {
     if (criticalInsights.length > 0) insightEvents.push("insight.critical");
     if (highInsights.length > 0) insightEvents.push("insight.high");
     if (insightEvents.length === 0) return;
-    const notifs = this.db.select().from(notifications).where(eq16(notifications.projectId, projectId)).all().filter((n) => n.enabled);
+    const notifs = this.db.select().from(notifications).where(eq17(notifications.projectId, projectId)).all().filter((n) => n.enabled);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = notif.config;
@@ -9031,7 +9938,7 @@ var Notifier = class {
     }
   }
   computeTransitions(runId, projectId) {
-    const thisRun = this.db.select().from(runs).where(eq16(runs.id, runId)).get();
+    const thisRun = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
     if (!thisRun) return [];
     const completeness = measurementRunCompleteness(this.db, runId);
     if (completeness.planned && !completeness.complete) {
@@ -9042,10 +9949,10 @@ var Notifier = class {
       });
       return [];
     }
-    const groupSiblings = this.db.select().from(runs).where(and12(
-      eq16(runs.projectId, projectId),
-      eq16(runs.kind, thisRun.kind),
-      eq16(runs.createdAt, thisRun.createdAt)
+    const groupSiblings = this.db.select().from(runs).where(and14(
+      eq17(runs.projectId, projectId),
+      eq17(runs.kind, thisRun.kind),
+      eq17(runs.createdAt, thisRun.createdAt)
     )).all();
     const stillPending = groupSiblings.some((r) => r.status === "queued" || r.status === "running");
     if (stillPending) return [];
@@ -9061,19 +9968,19 @@ var Notifier = class {
       return candidate.id > best.id ? candidate : best;
     });
     if (winner.id !== runId) return [];
-    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq16(projects.id, projectId)).get();
+    const projectLocations = this.db.select({ locations: projects.locations }).from(projects).where(eq17(projects.id, projectId)).get();
     const locationCount = Math.max(
       1,
       (projectLocations?.locations ?? []).length
     );
     const RECENT_FETCH_LIMIT = Math.max(8, locationCount * 4);
     const recentRuns = this.db.select().from(runs).where(
-      and12(
-        eq16(runs.projectId, projectId),
-        eq16(runs.kind, thisRun.kind),
-        or(eq16(runs.status, "completed"), eq16(runs.status, "partial"))
+      and14(
+        eq17(runs.projectId, projectId),
+        eq17(runs.kind, thisRun.kind),
+        or2(eq17(runs.status, "completed"), eq17(runs.status, "partial"))
       )
-    ).orderBy(desc6(runs.createdAt), desc6(runs.id)).limit(RECENT_FETCH_LIMIT).all();
+    ).orderBy(desc7(runs.createdAt), desc7(runs.id)).limit(RECENT_FETCH_LIMIT).all();
     const groups = groupRunsByCreatedAt(recentRuns);
     const currentGroupIdx = groups.findIndex((g) => g[0]?.createdAt === thisRun.createdAt);
     if (currentGroupIdx < 0) return [];
@@ -9088,7 +9995,7 @@ var Notifier = class {
       provider: querySnapshots.provider,
       location: querySnapshots.location,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(queries, eq16(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
+    }).from(querySnapshots).leftJoin(queries, eq17(querySnapshots.queryId, queries.id)).where(inArray6(querySnapshots.runId, currentRunIds)).all();
     const previousSnapshots = this.db.select({
       queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
@@ -9158,7 +10065,7 @@ var Notifier = class {
   }
   logDelivery(projectId, notificationId, event, status, error) {
     this.db.insert(auditLog).values({
-      id: crypto19.randomUUID(),
+      id: crypto20.randomUUID(),
       projectId,
       actor: "scheduler",
       action: `notification.${status}`,
@@ -9171,7 +10078,7 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-import { eq as eq17 } from "drizzle-orm";
+import { eq as eq18 } from "drizzle-orm";
 var log16 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(db, notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
@@ -9187,7 +10094,7 @@ var RunCoordinator = class {
   onInsightsGenerated;
   onAeroEvent;
   async onRunCompleted(runId, projectId) {
-    const runRow = this.db.select().from(runs).where(eq17(runs.id, runId)).get();
+    const runRow = this.db.select().from(runs).where(eq18(runs.id, runId)).get();
     const kind = runRow?.kind ?? RunKinds["answer-visibility"];
     if (runRow?.trigger === RunTriggers.probe) {
       log16.info("probe.skip-side-effects", { runId, projectId, kind });
@@ -9278,7 +10185,7 @@ var RunCoordinator = class {
    * so the Aero queue is never starved of a follow-up.
    */
   buildDiscoveryAeroContext(runId, projectId, status, error) {
-    const session = this.db.select().from(discoverySessions).where(eq17(discoverySessions.runId, runId)).get();
+    const session = this.db.select().from(discoverySessions).where(eq18(discoverySessions.runId, runId)).get();
     const competitorMap = session ? session.competitorMap : [];
     return {
       kind: RunKinds["aeo-discover-probe"],
@@ -9320,8 +10227,8 @@ function analysisResultFromInsights(insights2) {
 }
 
 // src/agent/session-registry.ts
-import crypto23 from "crypto";
-import { eq as eq19 } from "drizzle-orm";
+import crypto24 from "crypto";
+import { eq as eq20 } from "drizzle-orm";
 
 // src/agent/session.ts
 import fs7 from "fs";
@@ -10064,7 +10971,7 @@ function buildAeroStateTools(ctx, opts = {}) {
 }
 
 // src/agent/llm-usage.ts
-import crypto20 from "crypto";
+import crypto21 from "crypto";
 var AeroLlmUsageFeatures = {
   turn: "aero.turn"
 };
@@ -10083,7 +10990,7 @@ function recordLlmUsageEvent(args) {
     const usage = args.message.usage;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     args.db.insert(llmUsageEvents).values({
-      id: crypto20.randomUUID(),
+      id: crypto21.randomUUID(),
       projectId: args.projectId,
       runId: args.runId,
       agentSessionId: args.agentSessionId,
@@ -10159,7 +11066,7 @@ function splitAeroAnthropicSystemCachePayload(payload, model) {
 }
 
 // src/agent/tool-usage.ts
-import crypto21 from "crypto";
+import crypto22 from "crypto";
 var AeroToolEventStatuses = {
   success: "success",
   error: "error"
@@ -10222,7 +11129,7 @@ function createAeroToolUsageHooks(args) {
 function recordAgentToolEvent(args) {
   try {
     args.db.insert(agentToolEvents).values({
-      id: crypto21.randomUUID(),
+      id: crypto22.randomUUID(),
       projectId: args.projectId,
       agentSessionId: args.agentSessionId,
       toolCallId: args.toolCallId,
@@ -10449,8 +11356,8 @@ async function loadExternalMcpTools(servers, opts = {}) {
 }
 
 // src/agent/memory-store.ts
-import crypto22 from "crypto";
-import { and as and13, desc as desc7, eq as eq18, like, sql as sql7 } from "drizzle-orm";
+import crypto23 from "crypto";
+import { and as and15, desc as desc8, eq as eq19, like, sql as sql9 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -10464,7 +11371,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq18(agentMemory.projectId, projectId)).orderBy(desc7(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq19(agentMemory.projectId, projectId)).orderBy(desc8(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -10478,7 +11385,7 @@ function upsertMemoryEntry(db, args) {
     throw new Error(`memory key prefix "${COMPACTION_KEY_PREFIX}" is reserved for compaction notes`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = crypto22.randomUUID();
+  const id = crypto23.randomUUID();
   db.insert(agentMemory).values({
     id,
     projectId: args.projectId,
@@ -10495,12 +11402,12 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and13(eq18(agentMemory.projectId, args.projectId), eq18(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and15(eq19(agentMemory.projectId, args.projectId), eq19(agentMemory.key, args.key))).get();
   if (!row) throw new Error("memory upsert produced no row");
   return rowToDto(row);
 }
 function deleteMemoryEntry(db, projectId, key) {
-  const result = db.delete(agentMemory).where(and13(eq18(agentMemory.projectId, projectId), eq18(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and15(eq19(agentMemory.projectId, projectId), eq19(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -10515,7 +11422,7 @@ function writeCompactionNote(db, args) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const key = `${COMPACTION_KEY_PREFIX}${args.sessionId}:${now}`;
-  const id = crypto22.randomUUID();
+  const id = crypto23.randomUUID();
   let inserted;
   db.transaction((tx) => {
     tx.insert(agentMemory).values({
@@ -10529,16 +11436,16 @@ function writeCompactionNote(db, args) {
     }).run();
     const sessionPrefix = `${COMPACTION_KEY_PREFIX}${args.sessionId}:`;
     const existing = tx.select({ id: agentMemory.id, updatedAt: agentMemory.updatedAt }).from(agentMemory).where(
-      and13(
-        eq18(agentMemory.projectId, args.projectId),
+      and15(
+        eq19(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
-    ).orderBy(desc7(agentMemory.updatedAt)).all();
+    ).orderBy(desc8(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
-      tx.delete(agentMemory).where(sql7`${agentMemory.id} IN (${sql7.join(stale.map((s) => sql7`${s}`), sql7`, `)})`).run();
+      tx.delete(agentMemory).where(sql9`${agentMemory.id} IN (${sql9.join(stale.map((s) => sql9`${s}`), sql9`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and13(eq18(agentMemory.projectId, args.projectId), eq18(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and15(eq19(agentMemory.projectId, args.projectId), eq19(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -10765,7 +11672,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq19(agentSessions.projectId, projectId)).run();
+        }).where(eq20(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -10794,7 +11701,7 @@ var SessionRegistry = class {
     }
     const { provider, modelId } = resolveSessionProviderAndModel(this.opts.config, preferences);
     const systemPrompt = loadAeroSystemPrompt();
-    const sessionId = crypto23.randomUUID();
+    const sessionId = crypto24.randomUUID();
     const agent = createAeroSession({
       projectName,
       client: this.opts.client,
@@ -10999,7 +11906,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq19(agentSessions.projectId, projectId)).run();
+    }).where(eq20(agentSessions.projectId, projectId)).run();
   }
   /** Persist a session's transcript back to the DB. Call after any run settles. */
   save(projectName) {
@@ -11163,17 +12070,17 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq19(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq20(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq19(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq20(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.opts.db.insert(agentSessions).values({
-      id: params.id ?? crypto23.randomUUID(),
+      id: params.id ?? crypto24.randomUUID(),
       projectId: params.projectId,
       systemPrompt: params.systemPrompt,
       modelProvider: params.provider ?? params.modelProvider ?? AgentProviderIds.claude,
@@ -11186,14 +12093,14 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq19(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq20(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/agent-routes.ts
-import { eq as eq20 } from "drizzle-orm";
+import { eq as eq21 } from "drizzle-orm";
 function resolveProject(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq20(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq21(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -11202,7 +12109,7 @@ function registerAgentRoutes(app, opts) {
     "/projects/:name/agent/transcript",
     async (request) => {
       const project = resolveProject(opts.db, request.params.name);
-      const row = opts.db.select().from(agentSessions).where(eq20(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq21(agentSessions.projectId, project.id)).get();
       if (!row) {
         return { messages: [], modelProvider: null, modelId: null, updatedAt: null };
       }
@@ -11226,7 +12133,7 @@ function registerAgentRoutes(app, opts) {
     async (request) => {
       const project = resolveProject(opts.db, request.params.name);
       opts.sessionRegistry.reset(project.name);
-      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -11550,7 +12457,7 @@ Your previous reply was not valid JSON. Return ONLY a JSON object with exactly t
 }
 
 // src/snapshot-service.ts
-import { runAeoAudit } from "@ainyc/aeo-audit";
+import { runAeoAudit } from "@canonry/aeo-audit";
 
 // src/site-fetch.ts
 import https from "https";
@@ -12034,7 +12941,7 @@ function buildSnapshotSummary(companyName, queries2, providers, queryResults, au
       competitorCounts.set(competitor, (competitorCounts.get(competitor) ?? 0) + 1);
     }
   }
-  const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count]) => ({ name, count }));
+  const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count2]) => ({ name, count: count2 }));
   const defaultMeaning = totalComparisons > 0 ? `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider-query response${totalComparisons === 1 ? "" : "s"} across ${queries2.length} category queries.` : `No successful provider responses were returned across ${queries2.length} category queries.`;
   const failureNote = failedComparisons > 0 ? [
     `${failedComparisons} provider response${failedComparisons === 1 ? "" : "s"} failed and ${failedComparisons === 1 ? "was" : "were"} excluded from visibility totals.`
@@ -12169,20 +13076,20 @@ function clipText(value, length) {
 }
 
 // src/research-runner.ts
-import { and as and14, eq as eq21, inArray as inArray7, sql as sql8 } from "drizzle-orm";
+import { and as and16, eq as eq22, inArray as inArray7, sql as sql10 } from "drizzle-orm";
 var unfinishedResearchQueryStatuses = [ResearchQueryStatuses.queued, ResearchQueryStatuses.running];
 function finalResearchRunStatus(completed, failed) {
   if (failed === 0) return ResearchRunStatuses.completed;
   return completed > 0 ? ResearchRunStatuses.partial : ResearchRunStatuses.failed;
 }
 async function executeResearchRun(db, registry, runId, projectId) {
-  const run = db.select().from(researchRuns).where(and14(eq21(researchRuns.id, runId), eq21(researchRuns.projectId, projectId))).get();
+  const run = db.select().from(researchRuns).where(and16(eq22(researchRuns.id, runId), eq22(researchRuns.projectId, projectId))).get();
   if (!run || run.status !== ResearchRunStatuses.queued) return;
-  const project = db.select().from(projects).where(eq21(projects.id, projectId)).get();
+  const project = db.select().from(projects).where(eq22(projects.id, projectId)).get();
   if (!project) return;
   const provider = registry.get(run.provider);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and14(eq21(researchRuns.id, runId), eq21(researchRuns.status, ResearchRunStatuses.queued))).run();
+  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and16(eq22(researchRuns.id, runId), eq22(researchRuns.status, ResearchRunStatuses.queued))).run();
   if (claim.changes !== 1) return;
   let reserved = 0;
   let dispatched = 0;
@@ -12206,8 +13113,8 @@ async function executeResearchRun(db, registry, runId, projectId) {
     }
     reserved = run.totalQueries;
     reservation = { scope, period };
-    const rows = db.select().from(researchRunQueries).where(eq21(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
-    const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq21(competitors.projectId, projectId)).all().map((row) => row.domain);
+    const rows = db.select().from(researchRunQueries).where(eq22(researchRunQueries.researchRunId, runId)).orderBy(researchRunQueries.position).all();
+    const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(eq22(competitors.projectId, projectId)).all().map((row) => row.domain);
     const domains = effectiveDomains(project);
     const brands = effectiveBrandNames(project);
     const config = { ...provider.config, model: run.resolvedModel };
@@ -12215,7 +13122,7 @@ async function executeResearchRun(db, registry, runId, projectId) {
     await mapWithConcurrency(rows, Math.max(1, provider.config.quotaPolicy.maxConcurrency), async (row) => {
       try {
         const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and14(eq21(researchRunQueries.id, row.id), eq21(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
+        db.update(researchRunQueries).set({ status: ResearchQueryStatuses.running, startedAt }).where(and16(eq22(researchRunQueries.id, row.id), eq22(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
         const raw = await gate.run(async () => {
           dispatched++;
           return provider.adapter.executeTrackedQuery({ query: row.queryText, canonicalDomains: domains, competitorDomains, ...run.location ? { location: run.location } : {} }, config);
@@ -12242,7 +13149,7 @@ async function executeResearchRun(db, registry, runId, projectId) {
           citationState: determineCitationState(normalized, domains),
           rawResponse: raw.rawResponse,
           finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(and14(eq21(researchRunQueries.id, row.id), eq21(researchRunQueries.status, ResearchQueryStatuses.running))).run();
+        }).where(and16(eq22(researchRunQueries.id, row.id), eq22(researchRunQueries.status, ResearchQueryStatuses.running))).run();
         if (completed.changes === 1) incrementResearchProgress(db, runId, "completedQueries");
       } catch (error) {
         try {
@@ -12266,18 +13173,18 @@ async function executeResearchRun(db, registry, runId, projectId) {
   }
 }
 function incrementResearchProgress(db, runId, column) {
-  db.update(researchRuns).set({ [column]: sql8`${researchRuns[column]} + 1` }).where(eq21(researchRuns.id, runId)).run();
+  db.update(researchRuns).set({ [column]: sql10`${researchRuns[column]} + 1` }).where(eq22(researchRuns.id, runId)).run();
 }
 function markResearchQueryFailed(db, runId, queryId, error) {
   const message = error instanceof Error ? error.message : String(error);
-  const failed = db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and14(eq21(researchRunQueries.id, queryId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+  const failed = db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and16(eq22(researchRunQueries.id, queryId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
   if (failed.changes === 1) incrementResearchProgress(db, runId, "failedQueries");
 }
 function markUnfinishedResearchQueriesFailed(db, runId, error) {
-  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and14(eq21(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and16(eq22(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
 }
 function finalizeResearchRun(db, runId, fatalError) {
-  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq21(researchRunQueries.researchRunId, runId)).all();
+  const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq22(researchRunQueries.researchRunId, runId)).all();
   const completed = rows.filter((row) => row.status === ResearchQueryStatuses.completed).length;
   const failed = rows.filter((row) => row.status === ResearchQueryStatuses.failed).length;
   db.update(researchRuns).set({
@@ -12286,11 +13193,11 @@ function finalizeResearchRun(db, runId, fatalError) {
     failedQueries: failed,
     error: fatalError ?? (failed === rows.length ? "Every research query failed." : null),
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq21(researchRuns.id, runId)).run();
+  }).where(eq22(researchRuns.id, runId)).run();
 }
 
 // src/server.ts
-var _require3 = createRequire3(import.meta.url);
+var _require3 = createRequire4(import.meta.url);
 var { version: PKG_VERSION2 } = _require3("../package.json");
 var log20 = createLogger("Server");
 var DEFAULT_QUOTA = {
@@ -12349,14 +13256,14 @@ function summarizeProviderConfig(config) {
   };
 }
 function hashApiKey(key) {
-  return crypto24.createHash("sha256").update(key).digest("hex");
+  return crypto25.createHash("sha256").update(key).digest("hex");
 }
 var DASHBOARD_SCRYPT_KEYLEN = 64;
 var DASHBOARD_SCRYPT_COST = 1 << 15;
 var DASHBOARD_SCRYPT_MAXMEM = 64 * 1024 * 1024;
 function hashDashboardPassword(password) {
-  const salt = crypto24.randomBytes(16);
-  const derived = crypto24.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
+  const salt = crypto25.randomBytes(16);
+  const derived = crypto25.scryptSync(password, salt, DASHBOARD_SCRYPT_KEYLEN, {
     N: DASHBOARD_SCRYPT_COST,
     maxmem: DASHBOARD_SCRYPT_MAXMEM
   });
@@ -12377,14 +13284,14 @@ function verifyDashboardPassword(password, storedHash) {
     } catch {
       return { ok: false, needsRehash: false };
     }
-    const derived = crypto24.scryptSync(password, salt, expected.length, {
+    const derived = crypto25.scryptSync(password, salt, expected.length, {
       N: DASHBOARD_SCRYPT_COST,
       maxmem: DASHBOARD_SCRYPT_MAXMEM
     });
     if (derived.length !== expected.length)
       return { ok: false, needsRehash: false };
     return {
-      ok: crypto24.timingSafeEqual(derived, expected),
+      ok: crypto25.timingSafeEqual(derived, expected),
       needsRehash: false
     };
   }
@@ -12393,7 +13300,7 @@ function verifyDashboardPassword(password, storedHash) {
     const expected = Buffer.from(storedHash, "hex");
     if (candidate.length !== expected.length)
       return { ok: false, needsRehash: false };
-    const ok = crypto24.timingSafeEqual(candidate, expected);
+    const ok = crypto25.timingSafeEqual(candidate, expected);
     return { ok, needsRehash: ok };
   }
   return { ok: false, needsRehash: false };
@@ -12601,7 +13508,7 @@ async function createServer(opts) {
     (runId, projectId, result) => notifier.dispatchInsightWebhooks(runId, projectId, result),
     async (ctx) => {
       if (!sessionRegistry) return;
-      const project = opts.db.select({ name: projects.name }).from(projects).where(eq22(projects.id, ctx.projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq23(projects.id, ctx.projectId)).get();
       if (!project) return;
       let content;
       if (ctx.kind === RunKinds["aeo-discover-probe"]) {
@@ -12651,9 +13558,16 @@ async function createServer(opts) {
       app.log.error({ runId, err }, "Ads sync failed");
     });
   };
+  const siteAuditAbortControllers = /* @__PURE__ */ new Map();
   const runSiteAudit = (runId, projectId, auditOpts) => {
-    executeSiteAudit(opts.db, runId, projectId, auditOpts ?? {}).then(() => runCoordinator.onRunCompleted(runId, projectId)).catch((err) => {
+    const controller = new AbortController();
+    siteAuditAbortControllers.set(runId, controller);
+    executeSiteAudit(opts.db, runId, projectId, { ...auditOpts ?? {}, signal: controller.signal }).then(() => runCoordinator.onRunCompleted(runId, projectId)).catch((err) => {
       app.log.error({ runId, err }, "Site audit failed");
+    }).finally(() => {
+      if (siteAuditAbortControllers.get(runId) === controller) {
+        siteAuditAbortControllers.delete(runId);
+      }
     });
   };
   const adsCredentialStore = {
@@ -12944,7 +13858,7 @@ async function createServer(opts) {
       void (async () => {
         try {
           const report = await aeroClient.runDoctor({ project: projectName });
-          const project = opts.db.select().from(projects).where(eq22(projects.name, projectName)).get();
+          const project = opts.db.select().from(projects).where(eq23(projects.name, projectName)).get();
           if (!project) {
             app.log.warn({ projectName }, "doctor schedule fired for an unknown project");
             return;
@@ -12972,9 +13886,9 @@ async function createServer(opts) {
         });
         if (!probed) return;
         const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(
-          and15(
-            eq22(ccReleaseSyncs.release, probed.release),
-            eq22(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
+          and17(
+            eq23(ccReleaseSyncs.release, probed.release),
+            eq23(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
           )
         ).limit(1).get();
         if (alreadySynced) {
@@ -13129,7 +14043,7 @@ async function createServer(opts) {
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto24.randomBytes(32).toString("hex");
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto25.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
@@ -13204,11 +14118,11 @@ async function createServer(opts) {
   const googlePublicUrl = resolveGooglePublicUrl(opts.config, basePath);
   if (opts.config.apiKey) {
     const keyHash = hashApiKey(opts.config.apiKey);
-    const existing = opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto24.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto25.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -13232,7 +14146,7 @@ async function createServer(opts) {
   };
   const createSession = (apiKeyId) => {
     pruneExpiredSessions();
-    const sessionId = crypto24.randomBytes(32).toString("hex");
+    const sessionId = crypto25.randomBytes(32).toString("hex");
     sessions.set(sessionId, {
       apiKeyId,
       expiresAt: Date.now() + SESSION_TTL_MS
@@ -13256,7 +14170,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -13280,7 +14194,7 @@ async function createServer(opts) {
     if (!header) return false;
     const parts = header.split(" ");
     if (parts.length !== 2 || parts[0] !== "Bearer") return false;
-    const key = opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, hashApiKey(parts[1]))).get();
+    const key = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(parts[1]))).get();
     return Boolean(key && !key.revokedAt);
   };
   const namedAccountsInUse = () => anyUsersExist(opts.db);
@@ -13370,12 +14284,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq22(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq23(apiKeys.keyHash, hashApiKey(apiKey))).get();
       if (!key || key.revokedAt) {
         const err2 = authInvalid();
         return reply.status(err2.statusCode).send(err2.toJSON());
       }
-      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq23(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header(
         "set-cookie",
@@ -13592,7 +14506,7 @@ async function createServer(opts) {
         deps: {
           enqueueAutoExtract: ({ projectId, release: r }) => {
             const now = (/* @__PURE__ */ new Date()).toISOString();
-            const runId = crypto24.randomUUID();
+            const runId = crypto25.randomUUID();
             opts.db.insert(runs).values({
               id: runId,
               projectId,
@@ -13717,7 +14631,7 @@ async function createServer(opts) {
         ...inspectOpts,
         config: opts.config
       }).then(() => {
-        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq22(runs.id, runId)).get();
+        const finished = opts.db.select({ status: runs.status }).from(runs).where(eq23(runs.id, runId)).get();
         if (finished?.status === RunStatuses.completed || finished?.status === RunStatuses.partial) {
           return maybeRefreshGscCoverage(
             opts.db,
@@ -13759,6 +14673,12 @@ async function createServer(opts) {
         app.log.error({ runId, err }, "Job runner failed");
       });
     },
+    onRunCancelled: (runId) => {
+      const controller = siteAuditAbortControllers.get(runId);
+      if (controller && !controller.signal.aborted) {
+        controller.abort(new Error("Cancelled by user"));
+      }
+    },
     getRunnableProviderNames: () => registry.getAll().map((provider) => provider.adapter.name),
     getEffectiveProviderModels: () => effectiveProviderModels(registry),
     onProviderUpdate: (providerName, apiKey, model, baseUrl, incomingQuota) => {
@@ -13819,7 +14739,7 @@ async function createServer(opts) {
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         opts.db.insert(auditLog).values(
           targetProjectIds.map((projectId) => ({
-            id: crypto24.randomUUID(),
+            id: crypto25.randomUUID(),
             projectId,
             actor: "api",
             action: existing ? "provider.updated" : "provider.created",
@@ -13957,7 +14877,7 @@ async function createServer(opts) {
         }
       ];
     },
-    onGenerateQueries: async (providerName, count, project) => {
+    onGenerateQueries: async (providerName, count2, project) => {
       const provider = registry.get(providerName);
       if (!provider)
         throw new Error(`Provider "${providerName}" is not configured`);
@@ -13969,10 +14889,10 @@ async function createServer(opts) {
         language: project.language,
         existingQueries: project.existingQueries,
         siteText,
-        count
+        count: count2
       });
       const raw = await provider.adapter.generateText(prompt, provider.config);
-      return parseQueryResponse(raw, count);
+      return parseQueryResponse(raw, count2);
     },
     onSnapshotRequested: async (input) => {
       return snapshotService.createReport(input);
@@ -14087,7 +15007,7 @@ async function createServer(opts) {
   }
   checkLatestVersionForServer();
   scheduler.start();
-  for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq22(researchRuns.status, ResearchRunStatuses.queued)).all()) {
+  for (const run of opts.db.select({ id: researchRuns.id, projectId: researchRuns.projectId }).from(researchRuns).where(eq23(researchRuns.status, ResearchRunStatuses.queued)).all()) {
     dispatchResearchRun(run.id, run.projectId);
   }
   app.addHook("onClose", async () => {
@@ -14131,7 +15051,7 @@ function buildQueryGenerationPrompt(ctx) {
   );
   return lines.join("\n");
 }
-function parseQueryResponse(raw, count) {
+function parseQueryResponse(raw, count2) {
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const line of raw.split("\n")) {
@@ -14147,7 +15067,7 @@ function parseQueryResponse(raw, count) {
     if (seen.has(key)) continue;
     seen.add(key);
     results.push(cleaned);
-    if (results.length >= count) break;
+    if (results.length >= count2) break;
   }
   return results;
 }