@canonry/canonry 4.154.0 → 4.155.0

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

@@ -10,7 +10,7 @@ import {
   loadConfig,
   loadConfigRaw,
   saveConfigPatch
-} from "./chunk-ANSQ6JNO.js";
+} from "./chunk-OSHRDV36.js";
 import {
   CC_CACHE_DIR,
   DUCKDB_SPEC,
@@ -124,9 +124,16 @@ import {
   schedules,
   siteAuditPages,
   siteAuditSnapshots,
+  siteCrawlAttempts,
+  siteCrawlEdges,
+  siteCrawlEventReceipts,
+  siteCrawlFindings,
+  siteCrawlPages,
+  siteCrawlRunRequests,
+  siteCrawlSnapshots,
   toAlertView,
   usageCounters
-} from "./chunk-IFZS2TXV.js";
+} from "./chunk-VOL2BSM5.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -151,6 +158,10 @@ import {
   RunKinds,
   RunStatuses,
   RunTriggers,
+  SITE_AUDIT_DEFAULT_EDGE_LIMIT,
+  SITE_AUDIT_DEFAULT_PAGE_LIMIT,
+  SITE_AUDIT_MAX_EDGE_LIMIT,
+  SITE_AUDIT_MAX_PAGE_LIMIT,
   SKILL_MANIFEST_FILENAME,
   SchedulableRunKinds,
   SkillsClients,
@@ -200,6 +211,7 @@ import {
   normalizeIdTokens,
   normalizeMeasurementExecutionQueryText,
   normalizeServedModel,
+  normalizeSiteAuditRunRequest,
   normalizeUrlPath,
   notFound,
   parseMeasurementRunManifestV1,
@@ -210,6 +222,7 @@ import {
   resolveSnapshotRequestQueries,
   serializeForInlineScript,
   serializeRunError,
+  siteAuditRequestIdentity,
   skillsClientSchema,
   splitList,
   startOfDayHourInTimeZone,
@@ -218,7 +231,7 @@ import {
   validationError,
   winnabilityClassLabel,
   withRetry
-} from "./chunk-NNW7TJUZ.js";
+} from "./chunk-VIKPFI6F.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -553,7 +566,7 @@ import crypto24 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 and16, eq as eq22 } from "drizzle-orm";
 import Fastify from "fastify";
 import os5 from "os";
 
@@ -3547,11 +3560,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 });
     }
   }
@@ -4250,8 +4275,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);
@@ -6895,164 +6931,549 @@ function buildDiscoveryInsightTitle(input) {
 
 // src/execute-site-audit.ts
 import crypto16 from "crypto";
-import { eq as eq13 } from "drizzle-orm";
-import { runSitemapAudit } from "@ainyc/aeo-audit";
+import { and as and10, eq as eq13, sql as sql5 } from "drizzle-orm";
+import { runSiteCrawl } from "@canonry/aeo-audit";
 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
-  };
+  return { id: factor.id, name: factor.name, weight: factor.weight, score: factor.score };
 }
 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 "/";
   }
-  summaries.sort((a, b) => b.weight - a.weight || a.name.localeCompare(b.name));
-  return summaries;
 }
-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();
+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 project = db.select().from(projects).where(eq13(projects.id, projectId)).get();
-    if (!project) {
-      throw new Error(`Project not found: ${projectId}`);
+    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}).`
+      );
     }
-    const homepageUrl = toHomepageUrl(project.canonicalDomain);
-    const limit = clampSiteAuditLimit(opts.limit);
-    log12.info("start", { runId, projectId, homepageUrl, sitemapUrl: opts.sitemapUrl ?? null, limit });
-    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", {
-        runId,
-        projectId,
-        auditable,
-        audited: report.pagesAudited,
-        dropped: auditable - report.pagesAudited,
-        limit
-      });
+  } catch {
+  }
+  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();
+  const claim = db.update(runs).set({ status: "running", startedAt }).where(and10(eq13(runs.id, runId), eq13(runs.projectId, projectId), eq13(runs.status, "queued"))).run();
+  if (claim.changes === 0) return;
+  const attemptNumber = (db.select({ value: sql5`coalesce(max(${siteCrawlAttempts.attemptNumber}), 0)` }).from(siteCrawlAttempts).where(eq13(siteCrawlAttempts.runId, runId)).get()?.value ?? 0) + 1;
+  const attemptId = crypto16.randomUUID();
+  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);
     }
-    if (successCount === 0) {
-      throw new Error(
-        `Site audit could not successfully audit any of ${report.pagesAudited} page(s) from ${report.sitemapUrl}.`
-      );
+  };
+  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 = [
+        eq13(siteCrawlEdges.projectId, projectId),
+        eq13(siteCrawlEdges.runId, runId),
+        eq13(siteCrawlEdges.attemptId, attemptId)
+      ];
+      tx.update(siteCrawlEdges).set({ sourceNodeKey: nodeKey, updatedAt: now }).where(and10(
+        ...scope,
+        eq13(siteCrawlEdges.sourceUrl, url)
+      )).run();
+      tx.update(siteCrawlEdges).set({ targetNodeKey: nodeKey, updatedAt: now }).where(and10(
+        ...scope,
+        eq13(siteCrawlEdges.targetUrl, url)
+      )).run();
+      tx.update(siteCrawlPages).set({ canonicalNodeKey: nodeKey, updatedAt: now }).where(and10(
+        eq13(siteCrawlPages.projectId, projectId),
+        eq13(siteCrawlPages.runId, runId),
+        eq13(siteCrawlPages.attemptId, attemptId),
+        eq13(siteCrawlPages.canonicalUrl, url)
+      )).run();
     }
-    const factorAverages = computeFactorAverages(report.pages);
-    const status = pagesErrored === 0 ? "completed" : "partial";
-    const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  };
+  const persistPage = (tx, page, now) => {
+    const audit = page.audit;
+    tx.insert(siteCrawlPages).values({
+      id: crypto16.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 ? { factors: audit.factors.map(toPageFactor) } : {},
+      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 : sql5`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 ? { factors: audit.factors.map(toPageFactor) } : {},
+        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: crypto16.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(and10(
+      eq13(siteCrawlPages.projectId, projectId),
+      eq13(siteCrawlPages.runId, runId),
+      eq13(siteCrawlPages.attemptId, attemptId),
+      eq13(siteCrawlPages.nodeKey, key)
+    )).run();
+  };
+  const persistEvent = async (event) => {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
     db.transaction((tx) => {
-      tx.insert(siteAuditSnapshots).values({
+      const receipt = tx.select({ checksum: siteCrawlEventReceipts.checksum }).from(siteCrawlEventReceipts).where(and10(
+        eq13(siteCrawlEventReceipts.attemptId, attemptId),
+        eq13(siteCrawlEventReceipts.sequence, event.sequence),
+        eq13(siteCrawlEventReceipts.batchId, event.batchId)
+      )).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: 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
+        attemptId,
+        sequence: event.sequence,
+        batchId: event.batchId,
+        checksum: event.checksum,
+        receipt: { type: event.type },
+        createdAt: now
       }).run();
-      for (const page of report.pages) {
-        tx.insert(siteAuditPages).values({
+      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 : sql5`${siteCrawlAttempts.pagesEligible}`,
+          pagesErrored: event.type === "summary" ? observedErrorCount(observedPages.values()) : sql5`${siteCrawlAttempts.pagesErrored}`,
+          edgesDiscovered: progress.edgesObserved,
+          updatedAt: now
+        }).where(eq13(siteCrawlAttempts.id, attemptId)).run();
+      } else {
+        tx.update(siteCrawlAttempts).set({
+          lastEventSequence: event.sequence,
+          lastEventChecksum: event.checksum,
+          updatedAt: now
+        }).where(eq13(siteCrawlAttempts.id, attemptId)).run();
+      }
+    });
+  };
+  try {
+    const project = db.select().from(projects).where(eq13(projects.id, projectId)).get();
+    if (!project) throw new Error(`Project not found: ${projectId}`);
+    const homepageUrl = toHomepageUrl(project.canonicalDomain);
+    const maxPages = clampSiteAuditLimit(opts.maxPages ?? opts.limit);
+    const maxEdges = clampSiteAuditEdgeLimit(opts.maxEdges);
+    await assertSiteAuditUrlAllowed(homepageUrl, "canonicalDomain");
+    if (opts.sitemapUrl) await assertSiteAuditUrlAllowed(opts.sitemapUrl, "sitemapUrl");
+    log12.info("start", { runId, projectId, homepageUrl, maxPages, maxEdges, maxDepth: opts.maxDepth ?? null });
+    const report = await runSiteCrawl(homepageUrl, {
+      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 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);
+    const published = db.transaction((tx) => {
+      const claim2 = tx.update(runs).set({ status: terminalStatus, finishedAt }).where(and10(eq13(runs.id, runId), eq13(runs.status, "running"))).run();
+      if (claim2.changes === 0) return false;
+      if (hasAuditedPages) {
+        tx.insert(siteAuditSnapshots).values({
           id: crypto16.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: crypto16.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: crypto16.randomUUID(),
+        projectId,
+        runId,
+        attemptId,
+        rootUrl: 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: crypto16.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(eq13(siteCrawlAttempts.id, attemptId)).run();
+      return true;
     });
-    log12.info("completed", {
-      runId,
-      projectId,
-      status,
-      score: report.aggregateScore,
-      audited: report.pagesAudited,
-      errored: pagesErrored
+    if (!published) {
+      const current = db.select({ status: runs.status }).from(runs).where(eq13(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(eq13(siteCrawlAttempts.id, attemptId)).run();
+      tx.update(runs).set({
+        status: cancelled ? "cancelled" : "failed",
+        error: message,
+        finishedAt
+      }).where(and10(eq13(runs.id, runId), eq13(runs.status, "running"))).run();
     });
-  } 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 and11, eq as eq14, inArray as inArray4, isNull, sql as sql6 } from "drizzle-orm";
 var SNAPSHOT_BATCH_SIZE = 500;
 async function backfillAnswerVisibilityCommand(opts) {
   const config = loadConfig();
@@ -7068,7 +7489,7 @@ 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(
+    const runRows = projectFilter ? db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(and11(
       eq14(runs.kind, RunKinds["answer-visibility"]),
       inArray4(runs.projectId, scopedProjects.map((project) => project.id))
     )).all() : db.select({ id: runs.id, projectId: runs.projectId }).from(runs).where(eq14(runs.kind, RunKinds["answer-visibility"])).all();
@@ -7227,7 +7648,7 @@ function backfillNormalizedPaths(db, opts) {
     id: gaTrafficSnapshots.id,
     landingPage: gaTrafficSnapshots.landingPage,
     landingPageNormalized: gaTrafficSnapshots.landingPageNormalized
-  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
+  }).from(gaTrafficSnapshots).where(baseConditions.length > 0 ? and11(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -7299,7 +7720,7 @@ function backfillAiReferralPaths(db, opts) {
     id: gaAiReferrals.id,
     landingPage: gaAiReferrals.landingPage,
     landingPageNormalized: gaAiReferrals.landingPageNormalized
-  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and10(...baseConditions) : void 0).all();
+  }).from(gaAiReferrals).where(baseConditions.length > 0 ? and11(...baseConditions) : void 0).all();
   let updated = 0;
   let unchanged = 0;
   if (rows.length > 0) {
@@ -7367,7 +7788,7 @@ function backfillProjectAnswerMentions(db, projectId, opts) {
   const project = db.select().from(projects).where(eq14(projects.id, projectId)).get();
   if (!project) return { examined: 0, updated: 0, mentioned: 0 };
   const competitorDomains = db.select({ domain: competitors.domain }).from(competitors).where(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 runRows = db.select({ id: runs.id }).from(runs).where(and11(eq14(runs.kind, RunKinds["answer-visibility"]), eq14(runs.projectId, projectId))).all();
   const runIds = runRows.map((r) => r.id);
   let examined = 0;
   let updated = 0;
@@ -7516,7 +7937,7 @@ function readStoredGroundingSources(rawResponse) {
   return result;
 }
 async function backfillInsightsCommand(project, opts) {
-  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-B5AETQ5N.js");
+  const { IntelligenceService: IntelligenceService2 } = await import("./intelligence-service-G4NV3X36.js");
   const config = loadConfig();
   const db = createClient(config.database);
   migrate(db);
@@ -7686,7 +8107,7 @@ 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(
+  const events = db.select({ createdAt: auditLog.createdAt, action: auditLog.action, diff: auditLog.diff }).from(auditLog).where(and11(
     eq14(auditLog.projectId, project.id),
     inArray4(auditLog.action, ["keywords.appended", "keywords.deleted", "queries.appended", "queries.deleted", "queries.replaced"])
   )).orderBy(auditLog.createdAt).all();
@@ -7695,7 +8116,7 @@ async function backfillSnapshotAttributionCommand(opts) {
     runId: runs.id,
     createdAt: runs.createdAt,
     location: runs.location
-  }).from(runs).innerJoin(querySnapshots, eq14(querySnapshots.runId, runs.id)).where(and10(
+  }).from(runs).innerJoin(querySnapshots, eq14(querySnapshots.runId, runs.id)).where(and11(
     eq14(runs.projectId, project.id),
     isNull(querySnapshots.queryId),
     isNull(querySnapshots.queryText)
@@ -7718,7 +8139,7 @@ async function backfillSnapshotAttributionCommand(opts) {
       provider: querySnapshots.provider,
       createdAt: querySnapshots.createdAt,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).where(and10(
+    }).from(querySnapshots).where(and11(
       eq14(querySnapshots.runId, run.runId),
       isNull(querySnapshots.queryId),
       isNull(querySnapshots.queryText)
@@ -7884,7 +8305,7 @@ async function backfillTrafficClassificationCommand(opts) {
     dryRun: isDryRun,
     byBot: {}
   };
-  const unknownCountRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and10(
+  const unknownCountRow = db.select({ n: sql6`count(*)` }).from(rawEventSamples).where(and11(
     eq14(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).get();
@@ -7897,7 +8318,7 @@ async function backfillTrafficClassificationCommand(opts) {
     userAgent: rawEventSamples.userAgent,
     pathNormalized: rawEventSamples.pathNormalized,
     status: rawEventSamples.status
-  }).from(rawEventSamples).where(and10(
+  }).from(rawEventSamples).where(and11(
     eq14(rawEventSamples.eventType, "unknown"),
     inArray4(rawEventSamples.projectId, projectIds)
   )).all();
@@ -7965,7 +8386,7 @@ async function backfillTrafficClassificationCommand(opts) {
           aiUserFetchEventsHourly.status
         ],
         set: {
-          hits: sql5`${aiUserFetchEventsHourly.hits} + 1`,
+          hits: sql6`${aiUserFetchEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
@@ -7994,14 +8415,14 @@ async function backfillTrafficClassificationCommand(opts) {
           crawlerEventsHourly.status
         ],
         set: {
-          hits: sql5`${crawlerEventsHourly.hits} + 1`,
+          hits: sql6`${crawlerEventsHourly.hits} + 1`,
           updatedAt: now
         }
       }).run();
     }
   }
   if (!isDryRun) {
-    const afterRow = db.select({ n: sql5`count(*)` }).from(rawEventSamples).where(and10(
+    const afterRow = db.select({ n: sql6`count(*)` }).from(rawEventSamples).where(and11(
       eq14(rawEventSamples.eventType, "unknown"),
       inArray4(rawEventSamples.projectId, projectIds)
     )).get();
@@ -8436,7 +8857,7 @@ var ProviderRegistry = class {
 // src/scheduler.ts
 import crypto18 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 and12, eq as eq15, inArray as inArray5, notExists, sql as sql7 } from "drizzle-orm";
 var log13 = createLogger("Scheduler");
 var DEFAULT_HEALTH_CRON = "0 */6 * * *";
 function taskKey(projectId, kind) {
@@ -8468,7 +8889,7 @@ 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(
+      this.db.select({ one: sql7`1` }).from(schedules).where(and12(
         eq15(schedules.projectId, projects.id),
         eq15(schedules.kind, SchedulableRunKinds.doctor)
       ))
@@ -8551,7 +8972,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(and12(eq15(schedules.projectId, projectId), eq15(schedules.kind, kind))).get();
     if (schedule && schedule.enabled) {
       this.registerCronTask(schedule);
     }
@@ -8659,7 +9080,7 @@ 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(
+        const activeAdsRun = this.db.select({ id: runs.id }).from(runs).where(and12(
           eq15(runs.projectId, projectId),
           eq15(runs.kind, RunKinds["ads-sync"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
@@ -8734,7 +9155,7 @@ 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(
+        const active = this.db.select({ id: runs.id }).from(runs).where(and12(
           eq15(runs.projectId, projectId),
           eq15(runs.kind, RunKinds["site-audit"]),
           inArray5(runs.status, [RunStatuses.queued, RunStatuses.running])
@@ -8745,14 +9166,24 @@ var Scheduler = class {
           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 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,
@@ -8831,7 +9262,7 @@ 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 { eq as eq16, desc as desc6, and as and13, inArray as inArray6, or } from "drizzle-orm";
 import crypto19 from "crypto";
 var log15 = createLogger("Notifier");
 var Notifier = class {
@@ -9042,7 +9473,7 @@ var Notifier = class {
       });
       return [];
     }
-    const groupSiblings = this.db.select().from(runs).where(and12(
+    const groupSiblings = this.db.select().from(runs).where(and13(
       eq16(runs.projectId, projectId),
       eq16(runs.kind, thisRun.kind),
       eq16(runs.createdAt, thisRun.createdAt)
@@ -9068,7 +9499,7 @@ var Notifier = class {
     );
     const RECENT_FETCH_LIMIT = Math.max(8, locationCount * 4);
     const recentRuns = this.db.select().from(runs).where(
-      and12(
+      and13(
         eq16(runs.projectId, projectId),
         eq16(runs.kind, thisRun.kind),
         or(eq16(runs.status, "completed"), eq16(runs.status, "partial"))
@@ -10450,7 +10881,7 @@ 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 { and as and14, desc as desc7, eq as eq18, like, sql as sql8 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -10495,12 +10926,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(and14(eq18(agentMemory.projectId, args.projectId), eq18(agentMemory.key, args.key))).get();
   if (!row) throw new Error("memory upsert produced no row");
   return rowToDto(row);
 }
 function deleteMemoryEntry(db, projectId, key) {
-  const result = db.delete(agentMemory).where(and13(eq18(agentMemory.projectId, projectId), eq18(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and14(eq18(agentMemory.projectId, projectId), eq18(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -10529,16 +10960,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(
+      and14(
         eq18(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
     ).orderBy(desc7(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
-      tx.delete(agentMemory).where(sql7`${agentMemory.id} IN (${sql7.join(stale.map((s) => sql7`${s}`), sql7`, `)})`).run();
+      tx.delete(agentMemory).where(sql8`${agentMemory.id} IN (${sql8.join(stale.map((s) => sql8`${s}`), sql8`, `)})`).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(and14(eq18(agentMemory.projectId, args.projectId), eq18(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -11550,7 +11981,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";
@@ -12169,20 +12600,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 and15, eq as eq21, inArray as inArray7, sql as sql9 } 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(and15(eq21(researchRuns.id, runId), eq21(researchRuns.projectId, projectId))).get();
   if (!run || run.status !== ResearchRunStatuses.queued) return;
   const project = db.select().from(projects).where(eq21(projects.id, projectId)).get();
   if (!project) return;
   const provider = registry.get(run.provider);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and14(eq21(researchRuns.id, runId), eq21(researchRuns.status, ResearchRunStatuses.queued))).run();
+  const claim = db.update(researchRuns).set({ status: ResearchRunStatuses.running, startedAt: now }).where(and15(eq21(researchRuns.id, runId), eq21(researchRuns.status, ResearchRunStatuses.queued))).run();
   if (claim.changes !== 1) return;
   let reserved = 0;
   let dispatched = 0;
@@ -12215,7 +12646,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(and15(eq21(researchRunQueries.id, row.id), eq21(researchRunQueries.status, ResearchQueryStatuses.queued))).run();
         const raw = await gate.run(async () => {
           dispatched++;
           return provider.adapter.executeTrackedQuery({ query: row.queryText, canonicalDomains: domains, competitorDomains, ...run.location ? { location: run.location } : {} }, config);
@@ -12242,7 +12673,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(and15(eq21(researchRunQueries.id, row.id), eq21(researchRunQueries.status, ResearchQueryStatuses.running))).run();
         if (completed.changes === 1) incrementResearchProgress(db, runId, "completedQueries");
       } catch (error) {
         try {
@@ -12266,15 +12697,15 @@ 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]: sql9`${researchRuns[column]} + 1` }).where(eq21(researchRuns.id, runId)).run();
 }
 function markResearchQueryFailed(db, runId, queryId, error) {
   const message = error instanceof Error ? error.message : String(error);
-  const failed = db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and14(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(and15(eq21(researchRunQueries.id, queryId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
   if (failed.changes === 1) incrementResearchProgress(db, runId, "failedQueries");
 }
 function markUnfinishedResearchQueriesFailed(db, runId, error) {
-  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and14(eq21(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
+  db.update(researchRunQueries).set({ status: ResearchQueryStatuses.failed, error, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(and15(eq21(researchRunQueries.researchRunId, runId), inArray7(researchRunQueries.status, unfinishedResearchQueryStatuses))).run();
 }
 function finalizeResearchRun(db, runId, fatalError) {
   const rows = db.select({ status: researchRunQueries.status }).from(researchRunQueries).where(eq21(researchRunQueries.researchRunId, runId)).all();
@@ -12651,9 +13082,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 = {
@@ -12972,7 +13410,7 @@ async function createServer(opts) {
         });
         if (!probed) return;
         const alreadySynced = opts.db.select().from(ccReleaseSyncs).where(
-          and15(
+          and16(
             eq22(ccReleaseSyncs.release, probed.release),
             eq22(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)
           )
@@ -13759,6 +14197,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) => {