@canonry/canonry 5.20.4 → 5.22.0

package/dist/{chunk-NSKFW3NF.js → chunk-P5VXVFQW.js}

@@ -35,6 +35,7 @@ import {
   COMPETITOR_LANDSCAPE_OBSERVED_NAME_LIMIT,
   CcReleaseSyncStatuses,
   CheckCategories,
+  CheckNotificationPolicies,
   CheckScopes,
   CheckStatuses,
   CitationStates,
@@ -377,6 +378,8 @@ import {
   googleMarketingOAuthConnectRequestSchema,
   googleMarketingOAuthConnectResponseSchema,
   googleMarketingProviderSchema,
+  gradedReportMonths,
+  groupIsoDateRanges,
   gscCoverageSnapshotDtoSchema,
   gscCoverageSummaryDtoSchema,
   gscDeindexedRowSchema,
@@ -417,6 +420,7 @@ import {
   isTemplateLinkRatio,
   isTrendBaseline,
   isVertexGroundingRedirect,
+  isVisibilityCompareClassMetric,
   isoDateDaysBeforeInTimeZone,
   keywordDtoSchema,
   keywordGenerateRequestSchema,
@@ -628,6 +632,8 @@ import {
   reportLineChartLabel,
   reportMarketScope,
   reportMissRateLabel,
+  reportMonthSchema,
+  reportMonthsForDoctor,
   reportMoreChipLabel,
   reportMovementChangeCopy,
   reportOpportunityActionLine,
@@ -771,6 +777,7 @@ import {
   userListDtoSchema,
   validationError,
   visibilityCompareDtoSchema,
+  visibilityCompareSelectionSchema,
   visibilityReportQuerySchema,
   visibilityReportResponseSchema,
   visibilityStateFromAnswerMentioned,
@@ -792,10 +799,10 @@ import {
   wordpressSchemaDeployResultDtoSchema,
   wordpressSchemaStatusResultDtoSchema,
   wordpressStatusDtoSchema
-} from "./chunk-TOSPZ7I5.js";
+} from "./chunk-S5OSY3PI.js";
 
 // src/intelligence-service.ts
-import { eq as eq71, desc as desc32, asc as asc12, and as and60, ne as ne11, or as or18, inArray as inArray27, gte as gte18, lte as lte15, isNull as isNull13, sql as sql28, exists } from "drizzle-orm";
+import { eq as eq74, desc as desc32, asc as asc13, and as and62, ne as ne11, or as or18, inArray as inArray28, gte as gte20, lte as lte17, isNull as isNull13, sql as sql28, exists } from "drizzle-orm";
 
 // ../db/src/client.ts
 import { mkdirSync } from "fs";
@@ -16046,6 +16053,17 @@ function modelEvidenceStatesEqual(a, b) {
   if (a.status !== "mixed" || b.status !== "mixed") return false;
   return a.includesUnknown === b.includesUnknown && a.models.length === b.models.length && a.models.every((model, index2) => model === b.models[index2]);
 }
+function compareModelContinuity(from, to) {
+  const fromEvidence = classifyModelEvidence(from);
+  const toEvidence = classifyModelEvidence(to);
+  const ids = (evidence) => evidence.status === "known" ? [evidence.model] : evidence.status === "mixed" ? evidence.models : [];
+  const unknown = (evidence) => evidence.status === "unknown" || evidence.status === "mixed" && evidence.includesUnknown;
+  return {
+    status: unknown(fromEvidence) || unknown(toEvidence) ? "model-unknown" : fromEvidence.status === "known" && toEvidence.status === "known" && fromEvidence.model === toEvidence.model ? "included" : "model-discontinuous",
+    fromModels: ids(fromEvidence),
+    toModels: ids(toEvidence)
+  };
+}
 
 // ../api-routes/src/competitor-landscape.ts
 var COMPETITOR_LANDSCAPE_RANKED_ROW_LIMIT = 100;
@@ -24412,6 +24430,50 @@ function buildVisibilityReport(input) {
     populations
   });
 }
+function visibilityComparisonPopulation(run, selection) {
+  const targets = targetMap(run.definition);
+  const byClass = ALL_CLASSES.map((queryClass) => ({ queryClass, candidates: candidatesFor(run, selection, queryClass).candidates }));
+  const pooled = /* @__PURE__ */ new Map();
+  for (const { candidates } of byClass) {
+    for (const candidate of candidates) {
+      const existing = pooled.get(candidate.slot.id);
+      if (existing) existing.edges.push(...candidate.edges);
+      else pooled.set(candidate.slot.id, { ...candidate, edges: [...candidate.edges] });
+    }
+  }
+  const cohortKeys = new Map([...pooled.values()].map((candidate) => [candidate.slot.id, JSON.stringify({
+    definition: run.comparableDefinitionIds.at(-1) ?? run.definitionId,
+    query: candidate.slot.query,
+    execution: candidate.slot.executionId,
+    location: candidate.slot.location,
+    edges: candidate.edges.map((edge) => [edge.targetKey, edge.queryClass, [...edge.marketKeys].sort()]).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)))
+  })]));
+  const row = (candidate, queryClass) => {
+    const signals = targetValues(candidate, targets);
+    return {
+      queryId: candidate.slot.queryId ?? candidate.slot.queryKey,
+      queryText: candidate.slot.query,
+      provider: candidate.slot.provider,
+      model: candidate.observation.model,
+      answerMentioned: signals.mention,
+      mentionApplicable: candidate.edges.some((edge) => targets.get(edge.targetKey)?.mentionEligible === true),
+      citation: citationForCoverage(candidate, targets),
+      answerText: candidate.observation.answerText,
+      competitorDomains: [...new Set(candidate.edges.flatMap((edge) => edge.competitorDomains))],
+      competitorMentions: candidate.observation.competitorMentionDomains.filter((domain) => candidate.edges.some((edge) => edge.competitorDomains.includes(domain))),
+      competitorCitations: candidate.observation.competitorCitationDomains.filter((domain) => candidate.edges.some((edge) => edge.competitorDomains.includes(domain))),
+      cohortKey: cohortKeys.get(candidate.slot.id),
+      queryClass: queryClass === "unknown" ? null : queryClass
+    };
+  };
+  return {
+    snapshots: [...pooled.values()].filter((candidate) => candidate.observation !== null).map((candidate) => {
+      const classes = new Set(candidate.edges.map((edge) => edge.queryClass));
+      return row(candidate, classes.size === 1 ? candidate.edges[0].queryClass : null);
+    }),
+    classSnapshots: byClass.flatMap(({ queryClass, candidates }) => candidates.filter((candidate) => candidate.observation !== null).map((candidate) => row(candidate, queryClass)))
+  };
+}
 
 // ../api-routes/src/visibility-report.ts
 function normalizedText3(value) {
@@ -24928,6 +24990,13 @@ function comparableVersionIds(rows, versionId) {
   }
   return ids;
 }
+function comparableChainHeads(rows, rowsById) {
+  const heads = /* @__PURE__ */ new Map();
+  for (const row of [...rows].sort((left, right) => left.revision - right.revision)) {
+    for (const id of comparableVersionIds(rowsById, row.id)) heads.set(id, row.id);
+  }
+  return heads;
+}
 function assignmentSignature(plan, assignment) {
   const node = plan.executionNodes.find((candidate) => candidate.stableKey === assignment.executionNodeKey);
   if (!node) throw new Error(`Frozen assignment references missing execution node ${assignment.executionNodeKey}`);
@@ -25082,6 +25151,37 @@ async function visibilityReportRoutes(app) {
     async (request) => readVisibilityReport(app.db, resolveProject(app.db, request.params.name), request.query)
   );
 }
+function readVisibilityComparisonRuns(db, projectId, since, until, includeEvidence = true) {
+  const sourceRuns = db.select().from(runs).where(and21(
+    eq26(runs.projectId, projectId),
+    eq26(runs.kind, RunKinds["answer-visibility"]),
+    inArray10(runs.status, [RunStatuses.completed, RunStatuses.partial]),
+    notProbeRun(),
+    isNotNull(runs.measurementPlanVersionId),
+    isNull5(runs.measurementScope),
+    gte4(runs.createdAt, since),
+    lte4(runs.createdAt, until)
+  )).all();
+  const versionRows = db.select().from(measurementPlanVersions).where(eq26(measurementPlanVersions.projectId, projectId)).all();
+  const rowsById = new Map(versionRows.map((version) => [version.id, version]));
+  const versions = parseV2Versions(versionRows);
+  const heads = comparableChainHeads(versionRows, rowsById);
+  const byRun = loadVisibilitySnapshots(db, sourceRuns.map((run) => run.id));
+  let unavailable5 = false;
+  const selected = sourceRuns.flatMap((run) => {
+    const source = versions.get(run.measurementPlanVersionId);
+    if (!source) {
+      unavailable5 = true;
+      return [];
+    }
+    const presentation = versions.get(heads.get(source.row.id) ?? source.row.id) ?? source;
+    const snapshots = byRun.get(run.id) ?? [];
+    const models = new Map(snapshots.map((snapshot) => [snapshot.id, snapshot.model]));
+    const materialized = advancedRun(run, presentation.row, presentation.plan, snapshots, comparableVersionIds(rowsById, presentation.row.id), includeEvidence);
+    return [{ ...materialized, observations: materialized.observations.map((observation) => ({ ...observation, model: models.get(observation.answerId) ?? null })) }];
+  });
+  return { runs: selected, unavailable: unavailable5 };
+}
 
 // ../api-routes/src/query-tracking.ts
 import crypto21 from "crypto";
@@ -34822,15 +34922,15 @@ import { and as and35, desc as desc18, eq as eq39, inArray as inArray18 } from "
 
 // ../api-routes/src/visibility-compare.ts
 var VISIBILITY_COMPARE_MIN_RUNS = 5;
-function basketPairKey(queryId, provider) {
-  return JSON.stringify([queryId, provider]);
+function basketPairKey(queryId, provider, cohortKey) {
+  return JSON.stringify([queryId, provider, cohortKey ?? null]);
 }
 function restrict(snapshots, attribution, pairs) {
   const out = [];
   for (const snap of snapshots) {
     const resolved = resolveCurrentQuery(attribution, snap);
     if (!resolved) continue;
-    if (!pairs.has(basketPairKey(resolved.id, snap.provider))) continue;
+    if (!pairs.has(basketPairKey(resolved.id, snap.provider, snap.cohortKey))) continue;
     out.push({ ...snap, queryId: resolved.id });
   }
   return out;
@@ -34851,8 +34951,8 @@ function observedPairs(snapshots, attribution, queryIds) {
   for (const snap of snapshots) {
     const resolved = resolveCurrentQuery(attribution, snap);
     if (!resolved || !queryIds.has(resolved.id)) continue;
-    const pair = { queryId: resolved.id, provider: snap.provider };
-    pairs.set(basketPairKey(pair.queryId, pair.provider), pair);
+    const pair = { queryId: resolved.id, provider: snap.provider, cohortKey: snap.cohortKey };
+    pairs.set(basketPairKey(pair.queryId, pair.provider, pair.cohortKey), pair);
   }
   return pairs;
 }
@@ -34899,7 +34999,9 @@ function modelEvidenceOf(snaps) {
 function countPeriod(snaps, competitors2, queryClassOf, classificationAvailable, projectMatcher) {
   let checked = 0;
   let mentioned = 0;
+  let total = 0;
   let cited = 0;
+  let citationUnknown = 0;
   let competitorCited = 0;
   const perProvider = /* @__PURE__ */ new Map();
   const mentionedQueries = /* @__PURE__ */ new Set();
@@ -34911,21 +35013,26 @@ function countPeriod(snaps, competitors2, queryClassOf, classificationAvailable,
       mentioned += 1;
       mentionedQueries.add(snap.queryId);
     }
-    const isCited = snap.citationState === CitationStates.cited;
+    const citationKnown = snap.citationChecked !== false;
+    if (citationKnown) total += 1;
+    else citationUnknown += 1;
+    const isCited = citationKnown && snap.citationState === CitationStates.cited;
     if (isCited) cited += 1;
     const pp = perProvider.get(snap.provider) ?? { checked: 0, mentioned: 0, cited: 0 };
     if (snap.answerMentioned === true || snap.answerMentioned === false) pp.checked += 1;
     if (isMentioned) pp.mentioned += 1;
     if (isCited) pp.cited += 1;
     perProvider.set(snap.provider, pp);
-    if (competitorHosts.length > 0 && snap.citedDomains.length > 0) {
+    if (!citationKnown) continue;
+    if (snap.competitorCitations !== void 0) competitorCited += snap.competitorCitations.length;
+    else if (competitorHosts.length > 0 && snap.citedDomains.length > 0) {
       const citedHosts = snap.citedDomains.map((d) => hostOf(d)).filter((h) => h !== null && h.length > 0);
       for (const compHost of competitorHosts) {
         if (citedHosts.some((ch) => hostMatchesDomain(ch, compHost))) competitorCited += 1;
       }
     }
   }
-  const mentionShare = buildMentionShare(
+  let mentionShare = buildMentionShare(
     snaps.map((s) => ({
       // Share uses current identity; named-rate counts above deliberately keep
       // their historical persisted-boolean semantics.
@@ -34935,11 +35042,26 @@ function countPeriod(snaps, competitors2, queryClassOf, classificationAvailable,
     })),
     { competitors: competitors2, classificationAvailable }
   );
+  if (snaps.some((snapshot) => snapshot.competitorMentions !== void 0)) {
+    const selected = snaps.filter((snapshot) => (!classificationAvailable || queryClassOf(snapshot) === "non-brand") && snapshot.answerMentioned !== null);
+    const perCompetitor = competitors2.map((competitor) => ({
+      domain: competitor.domain,
+      mentionSnapshots: selected.filter((snapshot) => snapshot.competitorMentions?.includes(competitor.domain)).length
+    })).filter((row) => row.mentionSnapshots > 0).sort((a, b) => b.mentionSnapshots - a.mentionSnapshots || (a.domain < b.domain ? -1 : 1));
+    mentionShare = { ...mentionShare, breakdown: {
+      ...mentionShare.breakdown,
+      projectMentionSnapshots: selected.filter((snapshot) => snapshot.answerMentioned === true).length,
+      competitorMentionSnapshots: perCompetitor.reduce((total2, competitor) => total2 + competitor.mentionSnapshots, 0),
+      perCompetitor
+    } };
+  }
   return {
     checked,
     mentioned,
-    total: snaps.length,
+    total,
     cited,
+    citationUnknown,
+    citationEvidence: snaps.some((snapshot) => snapshot.citationChecked !== void 0),
     projectCited: cited,
     competitorCited,
     queriesMentioned: mentionedQueries.size,
@@ -34953,15 +35075,12 @@ function modelIds(evidence) {
   if (evidence.status === "mixed") return evidence.models;
   return [];
 }
-function isUnknownModelEvidence(evidence) {
-  return evidence.status === "unknown" || evidence.status === "mixed" && evidence.includesUnknown;
-}
 function computeVisibilityCompare(input) {
   const attribution = buildQueryAttribution(input.queries);
   const classifier = compileQueryClassifier(input.brandNames ?? []);
-  const classificationAvailable = classifier !== null;
+  const classificationAvailable = input.frozenClassification === true || classifier !== null;
   const queryTextById = new Map(input.queries.map((q) => [q.id, q.query]));
-  const queryClassOf = (snap) => classifier ? classifier.classify(queryTextById.get(snap.queryId) ?? snap.queryText) : null;
+  const queryClassOf = (snap) => input.frozenClassification ? snap.queryClass ?? null : classifier ? classifier.classify(queryTextById.get(snap.queryId) ?? snap.queryText) : null;
   const projectMatcher = compileBrandAliases(input.brandNames ?? []);
   const fromObs = observed(input.from.snapshots, attribution);
   const toObs = observed(input.to.snapshots, attribution);
@@ -34973,12 +35092,10 @@ function computeVisibilityCompare(input) {
   const fromCandidateModels = modelEvidenceOf(restrict(input.from.snapshots, attribution, pairsBoth));
   const toCandidateModels = modelEvidenceOf(restrict(input.to.snapshots, attribution, pairsBoth));
   const continuityProviders = [...candidateProviders].sort((a, b) => a.localeCompare(b)).map((provider) => {
-    const fromEvidence = classifyModelEvidence(fromCandidateModels.get(provider) ?? []);
-    const toEvidence = classifyModelEvidence(toCandidateModels.get(provider) ?? []);
-    const fromModels = modelIds(fromEvidence);
-    const toModels = modelIds(toEvidence);
-    const status = isUnknownModelEvidence(fromEvidence) || isUnknownModelEvidence(toEvidence) ? "model-unknown" : fromEvidence.status === "known" && toEvidence.status === "known" && fromEvidence.model === toEvidence.model ? "included" : "model-discontinuous";
-    return { provider, status, fromModels, toModels };
+    return { provider, ...compareModelContinuity(
+      fromCandidateModels.get(provider) ?? [],
+      toCandidateModels.get(provider) ?? []
+    ) };
   });
   const providersBoth = new Set(
     continuityProviders.filter((provider) => provider.status === "included").map((provider) => provider.provider)
@@ -34992,12 +35109,18 @@ function computeVisibilityCompare(input) {
   const toSnaps = restrict(input.to.snapshots, attribution, comparedPairs);
   const fromCounts = countPeriod(fromSnaps, input.competitors, queryClassOf, classificationAvailable, projectMatcher);
   const toCounts = countPeriod(toSnaps, input.competitors, queryClassOf, classificationAvailable, projectMatcher);
+  const fromClassSnaps = input.from.classSnapshots === void 0 ? fromSnaps : restrict(input.from.classSnapshots, attribution, comparedPairs);
+  const toClassSnaps = input.to.classSnapshots === void 0 ? toSnaps : restrict(input.to.classSnapshots, attribution, comparedPairs);
+  const noProjectMatcher = compileBrandAliases([]);
+  const fromShareCounts = input.frozenClassification ? countPeriod(fromClassSnaps, input.competitors, queryClassOf, true, noProjectMatcher) : fromCounts;
+  const toShareCounts = input.frozenClassification ? countPeriod(toClassSnaps, input.competitors, queryClassOf, true, noProjectMatcher) : toCounts;
   const shareCounts = (c) => ({
     proj: c.mentionShare.breakdown.projectMentionSnapshots,
     comp: c.mentionShare.breakdown.competitorMentionSnapshots
   });
-  const fromShare = shareCounts(fromCounts);
-  const toShare = shareCounts(toCounts);
+  const fromShare = shareCounts(fromShareCounts);
+  const toShare = shareCounts(toShareCounts);
+  const citationPeriod = (c, value) => c.citationEvidence ? { ...value, excludedUnknown: c.citationUnknown } : value;
   const metrics = [
     metric(
       "mention-share-of-voice",
@@ -35018,8 +35141,8 @@ function computeVisibilityCompare(input) {
       "Cited share of voice",
       "all",
       true,
-      input.competitors.length > 0 ? period(fromCounts.projectCited, fromCounts.projectCited + fromCounts.competitorCited) : unavailableCompetitivePeriod(fromCounts.projectCited),
-      input.competitors.length > 0 ? period(toCounts.projectCited, toCounts.projectCited + toCounts.competitorCited) : unavailableCompetitivePeriod(toCounts.projectCited),
+      citationPeriod(fromCounts, input.competitors.length > 0 ? period(fromCounts.projectCited, fromCounts.projectCited + fromCounts.competitorCited) : unavailableCompetitivePeriod(fromCounts.projectCited)),
+      citationPeriod(toCounts, input.competitors.length > 0 ? period(toCounts.projectCited, toCounts.projectCited + toCounts.competitorCited) : unavailableCompetitivePeriod(toCounts.projectCited)),
       continuityBlock
     ),
     metric(
@@ -35036,11 +35159,31 @@ function computeVisibilityCompare(input) {
       "Cited rate",
       "all",
       false,
-      period(fromCounts.cited, fromCounts.total),
-      period(toCounts.cited, toCounts.total),
+      citationPeriod(fromCounts, period(fromCounts.cited, fromCounts.total)),
+      citationPeriod(toCounts, period(toCounts.cited, toCounts.total)),
       continuityBlock
     )
   ];
+  const classPeriod = (snapshots, queryClass, signal) => {
+    if (!classificationAvailable) return { ...period(0, 0), availability: "classification-unavailable" };
+    const selected = snapshots.filter((snapshot) => queryClassOf(snapshot) === queryClass && (signal === "cited" || snapshot.mentionApplicable !== false));
+    const checked = selected.filter((snapshot) => signal === "mention" ? typeof snapshot.answerMentioned === "boolean" : snapshot.citationChecked !== false);
+    const numerator = checked.filter((snapshot) => signal === "mention" ? snapshot.answerMentioned === true : snapshot.citationState === CitationStates.cited).length;
+    return { ...period(numerator, checked.length), excludedUnknown: selected.length - checked.length };
+  };
+  for (const queryClass of ["branded", "non-brand"]) {
+    for (const signal of ["mention", "cited"]) {
+      metrics.push(metric(
+        `${signal}-rate-${queryClass}`,
+        signal === "mention" ? "Mention rate" : "Cited rate",
+        queryClass,
+        false,
+        classPeriod(fromClassSnaps, queryClass, signal),
+        classPeriod(toClassSnaps, queryClass, signal),
+        continuityBlock
+      ));
+    }
+  }
   const modelChanges = [...candidateProviders].sort((a, b) => a.localeCompare(b)).map((provider) => {
     const fromModels = modelIds(classifyModelEvidence(fromCandidateModels.get(provider) ?? []));
     const toModels = modelIds(classifyModelEvidence(toCandidateModels.get(provider) ?? []));
@@ -35088,7 +35231,7 @@ function computeVisibilityCompare(input) {
       comparedProviders: [...providersBoth].sort((a, b) => a.localeCompare(b)),
       providers: continuityProviders
     },
-    competitors: { from: fromCounts.competitors, to: toCounts.competitors }
+    competitors: { from: fromShareCounts.competitors, to: toShareCounts.competitors }
   };
 }
 
@@ -35306,59 +35449,196 @@ async function visibilityStatsRoutes(app) {
     return reply.send(response);
   });
   app.get("/projects/:name/visibility-compare", async (request, reply) => {
-    const project = resolveProject(app.db, request.params.name);
-    const { from: fromRaw, to: toRaw } = request.query;
-    if (fromRaw === void 0 || fromRaw === "") throw validationError('"from" (YYYY-MM) is required');
-    if (toRaw === void 0 || toRaw === "") throw validationError('"to" (YYYY-MM) is required');
-    let fromBounds;
-    let toBounds;
-    try {
-      fromBounds = calendarMonthBounds(fromRaw);
-    } catch (err) {
-      throw validationError(err instanceof RangeError ? `"from": ${err.message}` : '"from" must be in YYYY-MM format');
-    }
-    try {
-      toBounds = calendarMonthBounds(toRaw);
-    } catch (err) {
-      throw validationError(err instanceof RangeError ? `"to": ${err.message}` : '"to" must be in YYYY-MM format');
-    }
-    if (Date.parse(fromBounds.since) >= Date.parse(toBounds.since)) {
-      throw validationError('"from" must be a month strictly before "to"');
-    }
-    const projectQueries = app.db.select({ id: queries.id, query: queries.query }).from(queries).where(eq39(queries.projectId, project.id)).all();
-    const competitorRows2 = app.db.select({ domain: competitors.domain }).from(competitors).where(eq39(competitors.projectId, project.id)).all();
-    const competitorInputs = mentionShareCompetitorsFromDomains(competitorRows2.map((c) => c.domain));
-    const loadMonth = (bounds) => {
-      const sinceMs = Date.parse(bounds.since);
-      const untilMs = Date.parse(bounds.until);
-      const monthRuns = app.db.select({ id: runs.id, createdAt: runs.createdAt, status: runs.status }).from(runs).where(and35(eq39(runs.projectId, project.id), eq39(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).all().filter(
-        (r) => (r.status === RunStatuses.completed || r.status === RunStatuses.partial) && Date.parse(r.createdAt) >= sinceMs && Date.parse(r.createdAt) <= untilMs
-      );
-      const runIds = monthRuns.map((r) => r.id);
-      const snapshots = runIds.length > 0 && projectQueries.length > 0 ? app.db.select({
-        queryId: querySnapshots.queryId,
-        queryText: querySnapshots.queryText,
-        provider: querySnapshots.provider,
-        model: querySnapshots.model,
-        citationState: querySnapshots.citationState,
-        answerMentioned: querySnapshots.answerMentioned,
-        answerText: querySnapshots.answerText,
-        citedDomains: querySnapshots.citedDomains
-      }).from(querySnapshots).where(inArray18(querySnapshots.runId, runIds)).all() : [];
-      return { runCount: monthRuns.length, snapshots };
+    const dto = readVisibilityCompare(app.db, request.params.name, request.query);
+    return reply.send(dto);
+  });
+}
+function readVisibilityCompare(db, projectName, query) {
+  const project = resolveProject(db, projectName);
+  const selection = visibilityCompareSelectionSchema.safeParse(query);
+  if (!selection.success) throw validationError("Invalid comparison selection", { issues: selection.error.issues });
+  const filters = selection.data;
+  const scope = filters.scope ?? "project";
+  if (scope !== "project" && filters.scopeKey === void 0) throw validationError("A non-project comparison scope requires scopeKey.");
+  if (scope === "project" && filters.scopeKey !== void 0) throw validationError("scopeKey is not valid for project scope.");
+  if (scope === "market" && filters.marketKey !== void 0) throw validationError("marketKey is not valid for market scope.");
+  const { fromRaw, toRaw, fromBounds, toBounds } = compareMonths(query.from, query.to);
+  const providerKey2 = filters.provider === void 0 ? void 0 : normalizeText3(filters.provider);
+  const locationKey2 = filters.location === void 0 ? void 0 : normalizeText3(filters.location);
+  const scoped = scope !== "project" || filters.marketKey !== void 0;
+  let advancedComparison;
+  if (activeMeasurementPlan(db, project.id) !== null) {
+    const readerSelection = {
+      ...filters,
+      scope,
+      queryClass: "all",
+      location: locationKey2 === void 0 ? { kind: "all" } : locationKey2 === "none" ? { kind: "none" } : { kind: "exact", value: filters.location },
+      limit: 100
     };
-    const fromMonth = loadMonth(fromBounds);
-    const toMonth = loadMonth(toBounds);
-    const dto = computeVisibilityCompare({
+    const { missingScope: fromMissingScope, ...fromMonth2 } = loadAdvancedCompareMonth(db, project.id, fromBounds, readerSelection);
+    const { missingScope: toMissingScope, ...toMonth2 } = loadAdvancedCompareMonth(db, project.id, toBounds, readerSelection);
+    const missingScope = fromMissingScope ?? toMissingScope;
+    if (missingScope !== void 0 && fromMonth2.runCount + toMonth2.runCount === 0) throw validationError(missingScope.message, missingScope.details);
+    const queries2 = [...new Map([...fromMonth2.snapshots, ...toMonth2.snapshots].map((snapshot) => [snapshot.queryId, { id: snapshot.queryId, query: snapshot.queryText }])).values()];
+    advancedComparison = { ...computeVisibilityCompare({
       project: project.name,
-      queries: projectQueries,
-      competitors: competitorInputs,
-      brandNames: effectiveBrandNames(project),
-      from: { month: fromRaw, since: fromBounds.since, until: fromBounds.until, runCount: fromMonth.runCount, snapshots: fromMonth.snapshots },
-      to: { month: toRaw, since: toBounds.since, until: toBounds.until, runCount: toMonth.runCount, snapshots: toMonth.snapshots }
-    });
-    return reply.send(dto);
+      queries: queries2,
+      competitors: [...new Set([...fromMonth2.snapshots, ...toMonth2.snapshots].flatMap((snapshot) => snapshot.competitorDomains ?? []))].map((domain) => ({ domain, brandTokens: [] })),
+      frozenClassification: fromMonth2.classificationAvailable && toMonth2.classificationAvailable,
+      from: { ...fromMonth2, month: fromRaw, ...fromBounds },
+      to: { ...toMonth2, month: toRaw, ...toBounds }
+    }), selection: filters };
+    if (scoped) {
+      const unreadable = [fromMonth2.classificationAvailable ? null : fromRaw, toMonth2.classificationAvailable ? null : toRaw].filter((month) => month !== null);
+      if (unreadable.length > 0) {
+        throw validationError(`Property, group and market comparisons need frozen schema-v2 plan history; ${unreadable.join(" and ")} include runs whose plan cannot be reconstructed.`, { months: unreadable });
+      }
+      return advancedComparison;
+    }
+  }
+  if (advancedComparison === void 0 && scoped) throw validationError("Property, group and market comparison scopes require an Advanced portfolio.");
+  const projectQueries = db.select({ id: queries.id, query: queries.query }).from(queries).where(eq39(queries.projectId, project.id)).all();
+  const competitorRows2 = db.select({ domain: competitors.domain }).from(competitors).where(eq39(competitors.projectId, project.id)).all();
+  const competitorInputs = mentionShareCompetitorsFromDomains(competitorRows2.map((c) => c.domain));
+  const loadMonth = (bounds) => {
+    const runIds = legacyCompareRunIds(db, project.id, bounds);
+    const snapshots = runIds.length > 0 && projectQueries.length > 0 ? db.select({
+      queryId: querySnapshots.queryId,
+      queryText: querySnapshots.queryText,
+      provider: querySnapshots.provider,
+      model: querySnapshots.model,
+      citationState: querySnapshots.citationState,
+      answerMentioned: querySnapshots.answerMentioned,
+      answerText: querySnapshots.answerText,
+      citedDomains: querySnapshots.citedDomains,
+      location: querySnapshots.location
+    }).from(querySnapshots).where(inArray18(querySnapshots.runId, runIds)).all() : [];
+    return {
+      runCount: runIds.length,
+      snapshots: snapshots.filter((snapshot) => (providerKey2 === void 0 || normalizeText3(snapshot.provider) === providerKey2) && (locationKey2 === void 0 || (locationKey2 === "none" ? snapshot.location === null : snapshot.location !== null && normalizeText3(snapshot.location) === locationKey2)))
+    };
+  };
+  const fromMonth = loadMonth(fromBounds);
+  const toMonth = loadMonth(toBounds);
+  const dto = computeVisibilityCompare({
+    project: project.name,
+    queries: projectQueries,
+    competitors: competitorInputs,
+    brandNames: effectiveBrandNames(project),
+    from: { month: fromRaw, since: fromBounds.since, until: fromBounds.until, runCount: fromMonth.runCount, snapshots: fromMonth.snapshots },
+    to: { month: toRaw, since: toBounds.since, until: toBounds.until, runCount: toMonth.runCount, snapshots: toMonth.snapshots }
   });
+  if (advancedComparison !== void 0) {
+    const { from, to, basket, continuity: continuity2, modelChanges } = advancedComparison;
+    return {
+      ...dto,
+      selection: filters,
+      metrics: [
+        ...dto.metrics.filter((metric2) => !isVisibilityCompareClassMetric(metric2.key)),
+        ...advancedComparison.metrics.filter((metric2) => isVisibilityCompareClassMetric(metric2.key))
+      ],
+      classComparison: { from, to, basket, continuity: continuity2, modelChanges }
+    };
+  }
+  return { ...dto, selection: filters };
+}
+function compareMonths(fromRaw, toRaw) {
+  if (fromRaw === void 0 || fromRaw === "") throw validationError('"from" (YYYY-MM) is required');
+  if (toRaw === void 0 || toRaw === "") throw validationError('"to" (YYYY-MM) is required');
+  let fromBounds;
+  let toBounds;
+  try {
+    fromBounds = calendarMonthBounds(fromRaw);
+  } catch (err) {
+    throw validationError(err instanceof RangeError ? `"from": ${err.message}` : '"from" must be in YYYY-MM format');
+  }
+  try {
+    toBounds = calendarMonthBounds(toRaw);
+  } catch (err) {
+    throw validationError(err instanceof RangeError ? `"to": ${err.message}` : '"to" must be in YYYY-MM format');
+  }
+  if (Date.parse(fromBounds.since) >= Date.parse(toBounds.since)) {
+    throw validationError('"from" must be a month strictly before "to"');
+  }
+  return { fromRaw, toRaw, fromBounds, toBounds };
+}
+function legacyCompareRunIds(db, projectId, bounds) {
+  const sinceMs = Date.parse(bounds.since);
+  const untilMs = Date.parse(bounds.until);
+  return db.select({ id: runs.id, createdAt: runs.createdAt, status: runs.status }).from(runs).where(and35(eq39(runs.projectId, projectId), eq39(runs.kind, RunKinds["answer-visibility"]), notProbeRun())).all().filter(
+    (r) => (r.status === RunStatuses.completed || r.status === RunStatuses.partial) && Date.parse(r.createdAt) >= sinceMs && Date.parse(r.createdAt) <= untilMs
+  ).map((r) => r.id);
+}
+function loadAdvancedCompareMonth(db, projectId, bounds, selection, includeEvidence = true) {
+  const selected = readVisibilityComparisonRuns(db, projectId, bounds.since, bounds.until, includeEvidence);
+  const snapshots = [];
+  const classSnapshots = [];
+  let runCount = 0;
+  let missingScope;
+  for (const run of selected.runs) {
+    let population;
+    try {
+      population = visibilityComparisonPopulation(run, selection);
+    } catch (error) {
+      if (error instanceof VisibilityReportScopeError && error.details !== void 0) {
+        missingScope ??= error;
+        continue;
+      }
+      if (error instanceof VisibilityReportScopeError) throw validationError(error.message, error.details);
+      throw error;
+    }
+    runCount += 1;
+    const adapt = (snapshot) => ({
+      ...snapshot,
+      citationState: snapshot.citation === true ? CitationStates.cited : CitationStates["not-cited"],
+      citationChecked: snapshot.citation !== null,
+      citedDomains: []
+    });
+    snapshots.push(...population.snapshots.map(adapt));
+    classSnapshots.push(...population.classSnapshots.map(adapt));
+  }
+  return { runCount, snapshots, classSnapshots, classificationAvailable: !selected.unavailable, missingScope };
+}
+function readVisibilityContinuity(db, projectName, months) {
+  const project = resolveProject(db, projectName);
+  const { fromRaw, toRaw, fromBounds, toBounds } = compareMonths(months.from, months.to);
+  const bare = (snapshot) => ({
+    queryId: snapshot.queryId,
+    queryText: snapshot.queryText,
+    provider: snapshot.provider,
+    model: snapshot.model,
+    ...snapshot.cohortKey === void 0 ? {} : { cohortKey: snapshot.cohortKey },
+    citationState: CitationStates["not-cited"],
+    answerMentioned: null,
+    answerText: null,
+    citedDomains: []
+  });
+  const gate = (trackedQueries2, fromMonth, toMonth) => computeVisibilityCompare({
+    project: project.name,
+    queries: trackedQueries2,
+    competitors: [],
+    from: { month: fromRaw, ...fromBounds, ...fromMonth },
+    to: { month: toRaw, ...toBounds, ...toMonth }
+  }).continuity;
+  const trackedQueries = db.select({ id: queries.id, query: queries.query }).from(queries).where(eq39(queries.projectId, project.id)).all();
+  const loadProjectMonth = (bounds) => {
+    const runIds = legacyCompareRunIds(db, project.id, bounds);
+    const rows = runIds.length > 0 && trackedQueries.length > 0 ? db.select({ queryId: querySnapshots.queryId, queryText: querySnapshots.queryText, provider: querySnapshots.provider, model: querySnapshots.model }).from(querySnapshots).where(inArray18(querySnapshots.runId, runIds)).all() : [];
+    return { runCount: runIds.length, snapshots: rows.map(bare) };
+  };
+  const frames = [{ frame: "project", continuity: gate(trackedQueries, loadProjectMonth(fromBounds), loadProjectMonth(toBounds)) }];
+  if (activeMeasurementPlan(db, project.id) !== null) {
+    const selection = { scope: "project", queryClass: "all", location: { kind: "all" }, limit: 100 };
+    const fromMonth = loadAdvancedCompareMonth(db, project.id, fromBounds, selection, false);
+    const toMonth = loadAdvancedCompareMonth(db, project.id, toBounds, selection, false);
+    if (fromMonth.classificationAvailable && toMonth.classificationAvailable) {
+      const bareFrom = { runCount: fromMonth.runCount, snapshots: fromMonth.snapshots.map(bare) };
+      const bareTo = { runCount: toMonth.runCount, snapshots: toMonth.snapshots.map(bare) };
+      const frozenQueries = [...new Map([...bareFrom.snapshots, ...bareTo.snapshots].map((snapshot) => [snapshot.queryId, { id: snapshot.queryId, query: snapshot.queryText }])).values()];
+      frames.push({ frame: "class", continuity: gate(frozenQueries, bareFrom, bareTo) });
+    }
+  }
+  return frames;
 }
 
 // ../api-routes/src/results-export.ts
@@ -39055,9 +39335,18 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/visibility-compare",
     summary: "Compare AEO visibility month over month",
-    description: "Statistically honest month-over-month AEO comparison in one call. PRIMARY metric is share of voice (brand vs competitor mentions in the same answers), which is less exposed to broad model-wide naming propensity than an absolute rate but never bypasses model continuity. Rates are pooled per-snapshot over each month (invariant to sweep count), restricted to query/provider pairs present in BOTH months, and then restricted again to providers with exactly one known, identical configured model id in both months. `continuity` reports every provider and its model evidence; changed, mixed mid-month, or legacy-unknown models are excluded. When no provider remains, metrics return a continuity-blocked verdict rather than a directional call. `from` must be a month strictly before `to`. A silent upstream version bump under an unchanged configured id remains undetectable.",
+    description: "Statistically honest month-over-month AEO comparison in one call. PRIMARY metric is share of voice (brand vs competitor mentions in the same answers), which is less exposed to broad model-wide naming propensity than an absolute rate but never bypasses model continuity. Rates are pooled per-snapshot over each month (invariant to sweep count), restricted to query/provider pairs present in BOTH months, and then restricted again to providers with exactly one known, identical configured model id in both months. `continuity` reports every provider and its model evidence; changed, mixed mid-month, or legacy-unknown models are excluded. When no provider remains, metrics return a continuity-blocked verdict rather than a directional call. `from` must be a month strictly before `to`. Adds separate branded/non-brand mention and cited rates with classification-unavailable rather than pooled fallback. Advanced class metrics read frozen Property/market/execution assignments and reuse each answer once per class. Without a scope or marketKey the four original metrics keep the project frame (provider/location narrow it the same way for Simple and Advanced) and Advanced class metrics carry their own `classComparison` cohort. A scope or marketKey answers entirely from the frozen frame and is refused when either month holds runs whose plan cannot be reconstructed (schema v1). On frozen frames, answers with incomplete source capture leave every citation figure and are counted in `excludedUnknown`. A silent upstream version bump under an unchanged configured id remains undetectable.",
     tags: ["analytics"],
-    parameters: [nameParameter, compareFromQueryParameter, compareToQueryParameter],
+    parameters: [
+      nameParameter,
+      compareFromQueryParameter,
+      compareToQueryParameter,
+      { name: "scope", in: "query", description: "Advanced frozen population scope; default project.", schema: { type: "string", enum: ["project", "group", "market", "property"] } },
+      { name: "scopeKey", in: "query", description: "Stable Property Target, group, or market key; required for non-project scope.", schema: stringSchema },
+      { name: "marketKey", in: "query", description: "Intersect project/group/property selection with exact frozen market edges.", schema: stringSchema },
+      { name: "provider", in: "query", description: "Restrict both frames to one provider (case-insensitive).", schema: stringSchema },
+      { name: "location", in: "query", description: "Execution location label (case-insensitive), or none for no location.", schema: stringSchema }
+    ],
     responses: {
       200: jsonResponse("Month-over-month visibility comparison returned.", "VisibilityCompareDto"),
       400: errorResponse("Invalid or missing from/to months."),
@@ -42687,6 +42976,12 @@ var routeCatalog = [
     description: "Runs all global-scope checks (provider keys, etc.). Use ?check=<id> or ?check=<prefix>* (comma-separated) to filter. Returns a structured DoctorReport with per-check status, code, summary, remediation, and details.",
     tags: ["doctor"],
     parameters: [
+      {
+        name: "reportMonth",
+        in: "query",
+        description: "Report month YYYY-MM (not future). Omit for this month plus the previous month through UTC day 3. Read selection only; no writes or provider calls by report checks.",
+        schema: { type: "string", pattern: "^[1-9][0-9]{3}-(0[1-9]|1[0-2])$" }
+      },
       {
         name: "check",
         in: "query",
@@ -42695,7 +42990,8 @@ var routeCatalog = [
       }
     ],
     responses: {
-      200: jsonResponse("Doctor report returned.", "DoctorReportDto")
+      200: jsonResponse("Doctor report returned.", "DoctorReportDto"),
+      400: errorResponse("Invalid report month.")
     }
   },
   {
@@ -42706,6 +43002,12 @@ var routeCatalog = [
     tags: ["doctor"],
     parameters: [
       nameParameter,
+      {
+        name: "reportMonth",
+        in: "query",
+        description: "Report month YYYY-MM (not future). Omit for this month plus the previous month through UTC day 3. Read selection only; no writes or provider calls by report checks.",
+        schema: { type: "string", pattern: "^[1-9][0-9]{3}-(0[1-9]|1[0-2])$" }
+      },
       {
         name: "check",
         in: "query",
@@ -42715,6 +43017,7 @@ var routeCatalog = [
     ],
     responses: {
       200: jsonResponse("Doctor report returned.", "DoctorReportDto"),
+      400: errorResponse("Invalid report month."),
       404: errorResponse("Project not found.")
     }
   },
@@ -79791,6 +80094,322 @@ async function trafficRoutes(app, opts) {
   });
 }
 
+// ../api-routes/src/doctor/checks/report-sweeps.ts
+import { and as and52, asc as asc11, eq as eq58, gte as gte15, lte as lte15 } from "drizzle-orm";
+
+// ../api-routes/src/visibility-attribution.ts
+function buildQueryAttribution2(projectQueries) {
+  const byId = /* @__PURE__ */ new Map();
+  const byText = /* @__PURE__ */ new Map();
+  for (const q of projectQueries) {
+    byId.set(q.id, q);
+    byText.set(q.query, q);
+  }
+  return { byId, byText };
+}
+function resolveCurrentQuery2(attribution, snap) {
+  if (snap.queryId && attribution.byId.has(snap.queryId)) return attribution.byId.get(snap.queryId);
+  if (snap.queryText && attribution.byText.has(snap.queryText)) return attribution.byText.get(snap.queryText);
+  return void 0;
+}
+
+// ../api-routes/src/doctor/checks/report-sweeps.ts
+function slotCoverage(expected, answered2) {
+  return { signature: JSON.stringify([...expected].sort()), expected, answered: answered2 };
+}
+function inspectSweep(ctx, run) {
+  const base = { runId: run.id, planVersionId: run.measurementPlanVersionId };
+  if (run.measurementScope !== null) return { detail: { ...base, complete: false, reason: "spot-check" } };
+  if (run.queries !== null) return { detail: { ...base, complete: false, reason: "query-subset" } };
+  if (run.status !== RunStatuses.completed && run.status !== RunStatuses.partial) return { detail: { ...base, complete: false, reason: "not-terminal" } };
+  const snapshots = ctx.db.select({
+    queryId: querySnapshots.queryId,
+    queryText: querySnapshots.queryText,
+    provider: querySnapshots.provider,
+    answerMentioned: querySnapshots.answerMentioned,
+    answerText: querySnapshots.answerText,
+    measurementExecutionId: querySnapshots.measurementExecutionId
+  }).from(querySnapshots).where(eq58(querySnapshots.runId, run.id)).all();
+  if (snapshots.length === 0) return { detail: { ...base, complete: false, reason: "no-answers" } };
+  try {
+    if (run.measurementPlanVersionId) {
+      const version = ctx.db.select().from(measurementPlanVersions).where(and52(eq58(measurementPlanVersions.projectId, ctx.project.id), eq58(measurementPlanVersions.id, run.measurementPlanVersionId))).get();
+      if (!version) return { detail: { ...base, complete: false, reason: "missing-plan" } };
+      const plan = parseStoredMeasurementPlanAnyVersion(version.canonicalJson);
+      const manifest = measurementRunExpectedSlots(run, plan);
+      const expected2 = new Set(manifest.expectedSlots.map((slot) => measurementSlotKey(slot.executionId, slot.provider)));
+      const answered3 = /* @__PURE__ */ new Set();
+      let unbound = false;
+      for (const snapshot of snapshots) {
+        const executionId = snapshot.measurementExecutionId?.trim();
+        if (!executionId) {
+          unbound = true;
+          continue;
+        }
+        const key = measurementSlotKey(executionId, snapshot.provider);
+        if (expected2.has(key) && snapshot.answerText !== null) answered3.add(key);
+      }
+      const detail = {
+        ...base,
+        schemaVersion: plan.schemaVersion,
+        complete: expected2.size > 0 && !unbound && answered3.size === expected2.size,
+        reason: unbound ? "unbound-answers" : "frozen-plan",
+        expected: expected2.size,
+        answered: answered3.size,
+        providers: [...new Set(manifest.expectedSlots.map((slot) => slot.provider))],
+        ...plan.schemaVersion === MEASUREMENT_PLAN_V2_SCHEMA_VERSION ? {
+          targetKeys: plan.targets.map((target) => target.stableKey),
+          marketKeys: (plan.reportingScopes ?? []).map((market) => market.stableKey),
+          queryClasses: [...new Set(plan.assignments.map((assignment) => assignment.queryClass))]
+        } : {}
+      };
+      return unbound ? { detail } : { detail, coverage: slotCoverage(expected2, answered3) };
+    }
+    const stored = ctx.db.select().from(simpleMeasurementDefinitions).where(eq58(simpleMeasurementDefinitions.runId, run.id)).get();
+    const frozen = stored ? simpleMeasurementDefinitionSchema.parse(stored.definition) : null;
+    const project = ctx.db.select().from(projects).where(eq58(projects.id, ctx.project.id)).get();
+    const basket = frozen ? frozen.queries.map((query) => ({ id: query.queryId, query: query.queryText })) : ctx.db.select({ id: queries.id, query: queries.query }).from(queries).where(eq58(queries.projectId, project.id)).all();
+    const providers = frozen ? frozen.engines.map((engine) => engine.provider) : project.providers.length > 0 ? project.providers : [...new Set(snapshots.map((snapshot) => snapshot.provider))];
+    const attribution = buildQueryAttribution2(basket);
+    const expected = new Set(basket.flatMap((query) => providers.map((provider) => JSON.stringify([query.id, provider.trim().toLowerCase()]))));
+    const answered2 = /* @__PURE__ */ new Set();
+    for (const snapshot of snapshots) {
+      const query = resolveCurrentQuery2(attribution, snapshot);
+      if (!query || snapshot.answerMentioned === null && !snapshot.answerText) continue;
+      const key = JSON.stringify([query.id, snapshot.provider.trim().toLowerCase()]);
+      if (expected.has(key)) answered2.add(key);
+    }
+    return {
+      detail: { ...base, complete: expected.size > 0 && answered2.size === expected.size, reason: frozen ? "frozen-simple" : "current-basket", expected: expected.size, answered: answered2.size, providers },
+      coverage: slotCoverage(expected, answered2)
+    };
+  } catch {
+    return { detail: { ...base, complete: false, reason: "unreadable-evidence" } };
+  }
+}
+function monthCoverage(evidence) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const { detail, coverage } of evidence) {
+    if (!coverage) continue;
+    const group = groups.get(coverage.signature) ?? { expected: coverage.expected, answered: /* @__PURE__ */ new Set(), runIds: [] };
+    for (const key of coverage.answered) group.answered.add(key);
+    group.runIds.push(String(detail.runId));
+    groups.set(coverage.signature, group);
+  }
+  const all = [...groups.values()];
+  const ranked = all.filter((group) => !all.some((wider) => wider.expected.size > group.expected.size && [...group.expected].every((key) => wider.expected.has(key)))).map((group) => ({ ...group, covered: group.expected.size > 0 && [...group.expected].every((key) => group.answered.has(key)) })).sort((left, right) => Number(right.covered) - Number(left.covered) || right.answered.size / Math.max(1, right.expected.size) - left.answered.size / Math.max(1, left.expected.size));
+  const best = ranked[0];
+  return {
+    eligibleRunIds: ranked.filter((group) => group.covered).flatMap((group) => group.runIds),
+    coverage: best ? { expected: best.expected.size, answered: best.answered.size, sweeps: best.runIds.length } : null
+  };
+}
+var reportSweepsCheck = {
+  id: "report.sweeps",
+  category: CheckCategories.schedules,
+  scope: CheckScopes.project,
+  notificationPolicy: CheckNotificationPolicies.silent,
+  title: "Monthly report sweep readiness",
+  run(ctx) {
+    if (!ctx.project) return { status: CheckStatuses.skipped, code: "report.sweeps.no-project", summary: "Project context required." };
+    const now = /* @__PURE__ */ new Date();
+    const reportMonths = reportMonthsForDoctor(ctx.reportMonth, now);
+    const graded = gradedReportMonths(reportMonths, now);
+    const months = reportMonths.map((month) => {
+      const bounds = calendarMonthBounds(month);
+      const monthRuns = ctx.db.select().from(runs).where(and52(eq58(runs.projectId, ctx.project.id), eq58(runs.kind, RunKinds["answer-visibility"]), notProbeRun(), gte15(runs.createdAt, bounds.since), lte15(runs.createdAt, bounds.until))).orderBy(asc11(runs.createdAt), asc11(runs.id)).all();
+      const evidence = monthRuns.map((run) => inspectSweep(ctx, run));
+      return {
+        month,
+        // Through day 3 the new month is shown but only the closed month is graded.
+        graded: graded.has(month),
+        daysRemaining: Math.max(0, Math.ceil((Date.parse(bounds.until) - now.getTime()) / 864e5) - 1),
+        ...monthCoverage(evidence),
+        runs: evidence.map((run) => run.detail)
+      };
+    });
+    const missing = months.filter((month) => month.graded && month.eligibleRunIds.length === 0);
+    return {
+      status: missing.length ? CheckStatuses.warn : CheckStatuses.ok,
+      code: missing.length ? "report.sweeps.missing" : "report.sweeps.ready",
+      summary: missing.length ? `Whole-project sweeps do not yet answer every expected slot for ${missing.map((month) => `${month.month} (${month.daysRemaining} days left)`).join(", ")}.` : `Whole-project sweeps answer every expected slot for ${months.filter((month) => month.graded).map((month) => month.month).join(", ")}.`,
+      remediation: missing.length ? `Review the monthly schedule and sweep scope for ${ctx.project.name}; running a sweep spends provider quota.` : null,
+      details: { months }
+    };
+  }
+};
+
+// ../api-routes/src/doctor/checks/report-models.ts
+import { and as and53, eq as eq59, gte as gte16, inArray as inArray23, lte as lte16 } from "drizzle-orm";
+var reportModelsCheck = {
+  id: "report.models",
+  category: CheckCategories.providers,
+  scope: CheckScopes.project,
+  notificationPolicy: CheckNotificationPolicies.silent,
+  title: "Monthly report model continuity",
+  run(ctx) {
+    if (!ctx.project) return { status: CheckStatuses.skipped, code: "report.models.no-project", summary: "Project context required." };
+    const now = /* @__PURE__ */ new Date();
+    const reportMonths = reportMonthsForDoctor(ctx.reportMonth, now);
+    const graded = gradedReportMonths(reportMonths, now);
+    const months = reportMonths.flatMap((month) => {
+      const bounds = calendarMonthBounds(month);
+      const previous = new Date(Date.parse(bounds.since) - 1).toISOString().slice(0, 7);
+      const observations = ctx.db.select({ provider: querySnapshots.provider, model: querySnapshots.model, at: runs.createdAt }).from(querySnapshots).innerJoin(runs, eq59(runs.id, querySnapshots.runId)).where(and53(eq59(runs.projectId, ctx.project.id), eq59(runs.kind, RunKinds["answer-visibility"]), inArray23(runs.status, [RunStatuses.completed, RunStatuses.partial]), notProbeRun(), gte16(runs.createdAt, bounds.since), lte16(runs.createdAt, bounds.until))).all();
+      return readVisibilityContinuity(ctx.db, ctx.project.name, { from: previous, to: month }).map(({ frame, continuity: continuity2 }) => ({
+        month,
+        previousMonth: previous,
+        // Through day 3 the new month is shown but only the closed month is graded.
+        graded: graded.has(month),
+        selection: {},
+        frame,
+        continuity: continuity2.status,
+        providers: continuity2.providers.map((provider) => {
+          const modelDates = provider.toModels.map((model) => ({
+            model,
+            firstObservedAt: observations.filter((observation) => observation.provider === provider.provider && observation.model?.trim() === model).map((observation) => observation.at).sort()[0] ?? null
+          }));
+          const addedModelDates = modelDates.filter((model) => !provider.fromModels.includes(model.model));
+          return {
+            ...provider,
+            // Dates are project observations in this report month, not provider deployment dates.
+            firstObservedAtBasis: "new-project-provider-model-in-report-month",
+            firstObservedAt: addedModelDates.map((model) => model.firstObservedAt).filter((at) => at !== null).sort()[0] ?? null,
+            modelDates
+          };
+        })
+      }));
+    });
+    const frameLabel = (month) => month.frame === "class" ? `${month.month}, class basket` : month.month;
+    const gradedMonths = months.filter((month) => month.graded);
+    const excluded = gradedMonths.flatMap((month) => month.providers.filter((provider) => provider.status !== "included").map((provider) => `${provider.provider}: ${provider.fromModels.join(", ") || "unknown"} \u2192 ${provider.toModels.join(", ") || "unknown"} (${frameLabel(month)}; ${provider.firstObservedAt ? `new model first observed ${provider.firstObservedAt}` : "change date unknown"})`));
+    const insufficient = gradedMonths.filter((month) => month.providers.length === 0);
+    const flagged = gradedMonths.find((month) => month.providers.length === 0 || month.providers.some((provider) => provider.status !== "included")) ?? gradedMonths[0];
+    return {
+      status: excluded.length || insufficient.length ? CheckStatuses.warn : CheckStatuses.ok,
+      code: excluded.length ? "report.models.excluded" : insufficient.length ? "report.models.insufficient" : "report.models.continuous",
+      summary: excluded.length ? `Monthly comparison excludes ${excluded.join("; ")}.` : insufficient.length ? `No common query/provider evidence establishes model continuity for ${insufficient.map(frameLabel).join(", ")}.` : "All compared providers have continuous snapshot model evidence.",
+      remediation: excluded.length || insufficient.length ? `Inspect canonry visibility-compare ${ctx.project.name} --from ${flagged.previousMonth} --to ${flagged.month} --format json; do not pool excluded providers into a trend.` : null,
+      details: { months }
+    };
+  }
+};
+
+// ../api-routes/src/doctor/checks/report-daily-data.ts
+import { eq as eq60 } from "drizzle-orm";
+var REPORTING_LAG_DAYS = 3;
+function dateSpan(dates) {
+  const sorted = [...dates].sort();
+  return sorted.length === 0 ? null : { start: sorted[0], end: sorted.at(-1) };
+}
+function latestSyncRange(ctx, source) {
+  const projectId = ctx.project.id;
+  if (source === "ga") {
+    const rows2 = ctx.db.select({ date: gaDailyTotals.date, syncedAt: gaDailyTotals.syncedAt }).from(gaDailyTotals).where(eq60(gaDailyTotals.projectId, projectId)).all();
+    const latest2 = rows2.reduce((max2, row) => max2 === null || row.syncedAt > max2 ? row.syncedAt : max2, null);
+    const summary3 = ctx.db.select({ start: gaTrafficSummaries.periodStart, end: gaTrafficSummaries.periodEnd, syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq60(gaTrafficSummaries.projectId, projectId)).get();
+    if (summary3 && (latest2 === null || summary3.syncedAt >= latest2)) return { start: summary3.start, end: summary3.end, syncedAt: summary3.syncedAt };
+    const span2 = dateSpan(rows2.filter((row) => row.syncedAt === latest2).map((row) => row.date));
+    return span2 && latest2 !== null ? { ...span2, syncedAt: latest2 } : null;
+  }
+  const rows = ctx.db.select({ date: gscDailyTotals.date, createdAt: gscDailyTotals.createdAt }).from(gscDailyTotals).where(eq60(gscDailyTotals.projectId, projectId)).all();
+  const latest = rows.reduce((max2, row) => max2 === null || row.createdAt > max2 ? row.createdAt : max2, null);
+  const span = dateSpan(rows.filter((row) => row.createdAt === latest).map((row) => row.date));
+  if (!span || latest === null) return null;
+  const watermark = ctx.db.select({ through: gscDataWatermarks.syncedThroughDate, updatedAt: gscDataWatermarks.updatedAt }).from(gscDataWatermarks).where(eq60(gscDataWatermarks.projectId, projectId)).get();
+  return watermark?.through && watermark.updatedAt === latest && watermark.through > span.end ? { start: span.start, end: watermark.through, syncedAt: latest } : { ...span, syncedAt: latest };
+}
+function dailyCoverage(ctx, month, source) {
+  const project = ctx.project;
+  const connection = source === "ga" ? ctx.ga4CredentialStore?.getConnection(project.name) ?? ctx.googleConnectionStore?.getConnection(project.canonicalDomain, "ga4") : ctx.googleConnectionStore?.getConnection(project.canonicalDomain, "gsc");
+  const stored = source === "ga" ? ctx.db.select({ date: gaDailyTotals.date, count: gaDailyTotals.sessions }).from(gaDailyTotals).where(eq60(gaDailyTotals.projectId, project.id)).all() : ctx.db.select({ date: gscDailyTotals.date, count: gscDailyTotals.impressions }).from(gscDailyTotals).where(eq60(gscDailyTotals.projectId, project.id)).all();
+  if (!connection && stored.length === 0) return null;
+  const bounds = calendarMonthBounds(month);
+  const start = bounds.since.slice(0, 10);
+  const end = bounds.until.slice(0, 10);
+  const timeZone = source === "gsc" ? "America/Los_Angeles" : "UTC";
+  const matureThrough = isoDateDaysBeforeInTimeZone((/* @__PURE__ */ new Date()).toISOString(), REPORTING_LAG_DAYS, timeZone);
+  const created = ctx.db.select({ date: projects.createdAt }).from(projects).where(eq60(projects.id, project.id)).get().date.slice(0, 10);
+  const connectedAt = connection?.createdAt?.slice(0, 10) ?? created;
+  const onboardingDate = [connectedAt, ...stored.map((row) => row.date)].sort()[0];
+  const byDate = new Map(stored.map((row) => [row.date, row.count]));
+  const coverage = latestSyncRange(ctx, source);
+  const lagFloor = coverage ? isoDateDaysBeforeInTimeZone(coverage.syncedAt, REPORTING_LAG_DAYS, timeZone) : null;
+  const zeroProvenThrough = coverage && lagFloor ? coverage.end < lagFloor ? coverage.end : lagFloor : null;
+  const absent = [];
+  let observedDays = 0;
+  let observedZeroDays = 0;
+  let queriedEmptyDays = 0;
+  let pendingDays = 0;
+  let beforeConnectionDays = 0;
+  for (const date of calendarDateRange(start, end)) {
+    if (date > matureThrough) {
+      pendingDays++;
+      continue;
+    }
+    if (date < onboardingDate) {
+      beforeConnectionDays++;
+      continue;
+    }
+    const count4 = byDate.get(date);
+    if (count4 !== void 0) {
+      observedDays++;
+      if (count4 === 0) observedZeroDays++;
+    } else if (coverage && zeroProvenThrough && date >= coverage.start && date <= zeroProvenThrough) queriedEmptyDays++;
+    else absent.push(date);
+  }
+  return {
+    source,
+    start,
+    end,
+    matureThrough,
+    timeZone,
+    timeZoneBasis: source === "ga" ? "fallback" : "provider",
+    onboardingDate,
+    observedDays,
+    observedZeroDays,
+    // Queried by the latest sync and returned no row: the source reports no activity for them.
+    latestSyncRange: coverage,
+    zeroProvenThrough,
+    queriedEmptyDays,
+    unknownDays: absent.length,
+    unknownRanges: groupIsoDateRanges(absent),
+    // Only the latest sync's range is on record, so an absent date outside it may never have been queried.
+    confirmedMissingDays: 0,
+    pendingDays,
+    beforeConnectionDays
+  };
+}
+var reportDailyDataCheck = {
+  id: "report.daily-data",
+  category: CheckCategories.integrations,
+  scope: CheckScopes.project,
+  notificationPolicy: CheckNotificationPolicies.silent,
+  title: "Monthly report daily data coverage",
+  run(ctx) {
+    if (!ctx.project) return { status: CheckStatuses.skipped, code: "report.daily-data.no-project", summary: "Project context required." };
+    const months = reportMonthsForDoctor(ctx.reportMonth).map((month) => ({ month, sources: ["ga", "gsc"].flatMap((source) => {
+      const coverage = dailyCoverage(ctx, month, source);
+      return coverage ? [coverage] : [];
+    }) }));
+    const sources = months.flatMap((month) => month.sources);
+    if (!sources.length) return { status: CheckStatuses.skipped, code: "report.daily-data.not-connected", summary: "No connected or stored GA4/Search Console evidence.", details: { months } };
+    const unknown = sources.reduce((sum, source) => sum + source.unknownDays, 0);
+    const mature = sources.some((source) => source.observedDays + source.queriedEmptyDays + source.unknownDays > 0);
+    const gaUnknown = sources.some((source) => source.source === "ga" && source.unknownDays > 0);
+    const oldest = months[0].month;
+    const days = inclusiveDayCount(calendarMonthBounds(oldest).since.slice(0, 10), (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)) ?? 1;
+    const commands = [...new Set(sources.filter((source) => source.unknownDays > 0).map((source) => source.source === "ga" ? `canonry ga sync ${ctx.project.name} --days ${Math.min(90, days)}` : `canonry google sync ${ctx.project.name} --days ${Math.min(480, days)}`))];
+    return {
+      status: unknown ? CheckStatuses.warn : mature ? CheckStatuses.ok : CheckStatuses.skipped,
+      code: unknown ? "report.daily-data.unknown" : mature ? "report.daily-data.observed" : "report.daily-data.pending",
+      summary: unknown ? `${unknown} source-days have unknown coverage: no row, and not proven quiet by the latest sync (outside its range, or too close to when it ran for the source to have published them). Absent rows can mean zero activity or unsynced data.` : mature ? "Every mature date has an observed daily total or was queried by the latest sync and returned no activity." : "No mature dates since connection; reporting latency is excluded.",
+      remediation: unknown ? `Review coverage and backfill: ${commands.map((command) => `\`${command}\``).join("; ")}. A sync whose window covers these dates records them as queried, so dates it returns no row for then count as zero activity.${gaUnknown && days > 90 ? " GA4 sync supports at most 90 days; older unknown dates need an external export." : ""}` : null,
+      details: { months }
+    };
+  }
+};
+
 // ../api-routes/src/doctor/checks/agent.ts
 import crypto46 from "crypto";
 import fs6 from "fs";
@@ -80119,7 +80738,7 @@ var skillsTriggerSurfaceCheck = {
 var AGENT_CHECKS = [skillsInstalledCheck, skillsCurrentCheck, skillsTriggerSurfaceCheck];
 
 // ../api-routes/src/doctor/checks/backlinks.ts
-import { and as and52, eq as eq58 } from "drizzle-orm";
+import { and as and54, eq as eq61 } from "drizzle-orm";
 function skippedNoProject() {
   return {
     status: CheckStatuses.skipped,
@@ -80135,8 +80754,8 @@ var BACKLINKS_CHECKS = [
     title: "Backlinks source connected",
     run: (ctx) => {
       if (!ctx.project) return skippedNoProject();
-      const projectRow = ctx.db.select({ autoExtract: projects.autoExtractBacklinks }).from(projects).where(eq58(projects.id, ctx.project.id)).get();
-      const readySync = ctx.db.select({ id: ccReleaseSyncs.id }).from(ccReleaseSyncs).where(eq58(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).limit(1).get();
+      const projectRow = ctx.db.select({ autoExtract: projects.autoExtractBacklinks }).from(projects).where(eq61(projects.id, ctx.project.id)).get();
+      const readySync = ctx.db.select({ id: ccReleaseSyncs.id }).from(ccReleaseSyncs).where(eq61(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).limit(1).get();
       const ccConnected = projectRow?.autoExtract === true && !!readySync;
       const connected = [];
       if (ccConnected) connected.push(BacklinkSources.commoncrawl);
@@ -80149,9 +80768,9 @@ var BACKLINKS_CHECKS = [
           details: { commoncrawl: ccConnected }
         };
       }
-      const ccHasData = ccConnected ? !!ctx.db.select({ id: backlinkSummaries.id }).from(backlinkSummaries).where(and52(
-        eq58(backlinkSummaries.projectId, ctx.project.id),
-        eq58(backlinkSummaries.source, BacklinkSources.commoncrawl)
+      const ccHasData = ccConnected ? !!ctx.db.select({ id: backlinkSummaries.id }).from(backlinkSummaries).where(and54(
+        eq61(backlinkSummaries.projectId, ctx.project.id),
+        eq61(backlinkSummaries.source, BacklinkSources.commoncrawl)
       )).limit(1).get() : false;
       return {
         status: CheckStatuses.ok,
@@ -80311,7 +80930,7 @@ var BING_AUTH_CHECKS = [
 ];
 
 // ../api-routes/src/doctor/checks/content.ts
-import { eq as eq59 } from "drizzle-orm";
+import { eq as eq62 } from "drizzle-orm";
 var WINNABILITY_COVERAGE_WARN_THRESHOLD = 0.8;
 var UNCLASSIFIED_DOMAIN_SAMPLE_LIMIT = 10;
 function skippedNoProject2() {
@@ -80324,7 +80943,7 @@ function skippedNoProject2() {
 }
 function loadProject(ctx) {
   if (!ctx.project) return null;
-  return ctx.db.select().from(projects).where(eq59(projects.id, ctx.project.id)).get() ?? null;
+  return ctx.db.select().from(projects).where(eq62(projects.id, ctx.project.id)).get() ?? null;
 }
 function percent(value) {
   return Math.round(value * 100);
@@ -80416,7 +81035,7 @@ var CONTENT_CHECK_BY_ID = Object.fromEntries(
 );
 
 // ../api-routes/src/doctor/checks/ads.ts
-import { eq as eq60 } from "drizzle-orm";
+import { eq as eq63 } from "drizzle-orm";
 var RECENT_SYNC_WARN_DAYS = 7;
 var RECENT_SYNC_FAIL_DAYS = 30;
 var adsConnectionCheck = {
@@ -80433,7 +81052,7 @@ var adsConnectionCheck = {
         remediation: null
       };
     }
-    const row = ctx.db.select().from(adsConnections).where(eq60(adsConnections.projectId, ctx.project.id)).get();
+    const row = ctx.db.select().from(adsConnections).where(eq63(adsConnections.projectId, ctx.project.id)).get();
     if (!row) {
       return {
         status: CheckStatuses.skipped,
@@ -80483,7 +81102,7 @@ var adsRecentSyncCheck = {
         remediation: null
       };
     }
-    const row = ctx.db.select().from(adsConnections).where(eq60(adsConnections.projectId, ctx.project.id)).get();
+    const row = ctx.db.select().from(adsConnections).where(eq63(adsConnections.projectId, ctx.project.id)).get();
     if (!row) {
       return {
         status: CheckStatuses.skipped,
@@ -80674,7 +81293,7 @@ var ga4ConnectionCheck = {
 var GA_AUTH_CHECKS = [ga4ConnectionCheck];
 
 // ../api-routes/src/doctor/checks/data-freshness.ts
-import { and as and53, desc as desc28, eq as eq61, inArray as inArray23 } from "drizzle-orm";
+import { and as and55, desc as desc28, eq as eq64, inArray as inArray24 } from "drizzle-orm";
 var GA_DATA_AGING_DAYS = 3;
 var GA_DATA_STALE_DAYS = 5;
 var GSC_DATA_AGING_DAYS = 5;
@@ -80702,7 +81321,7 @@ function skipped(code, summary3) {
   return { status: CheckStatuses.skipped, code, summary: summary3, remediation: null };
 }
 function lastSyncAgeDays(ctx, kinds) {
-  const row = ctx.db.select({ createdAt: runs.createdAt }).from(runs).where(and53(eq61(runs.projectId, ctx.project.id), inArray23(runs.kind, kinds), eq61(runs.status, "completed"))).orderBy(desc28(runs.createdAt)).limit(1).get();
+  const row = ctx.db.select({ createdAt: runs.createdAt }).from(runs).where(and55(eq64(runs.projectId, ctx.project.id), inArray24(runs.kind, kinds), eq64(runs.status, "completed"))).orderBy(desc28(runs.createdAt)).limit(1).get();
   if (!row?.createdAt) return null;
   const age = Math.floor((Date.now() - Date.parse(row.createdAt)) / DAY_MS2);
   return Number.isFinite(age) ? age : null;
@@ -80798,7 +81417,7 @@ var gaRecentDataCheck = {
     const connection = gaConnected(ctx);
     if (connection === "store-unavailable") return skipped("ga.data.store-unavailable", "No GA4 credential store configured for this deployment.");
     if (connection === "not-connected") return skipped("ga.data.not-connected", "GA4 is not connected for this project.");
-    const newest = ctx.db.select({ date: gaDailyTotals.date }).from(gaDailyTotals).where(eq61(gaDailyTotals.projectId, ctx.project.id)).orderBy(desc28(gaDailyTotals.date)).limit(1).get();
+    const newest = ctx.db.select({ date: gaDailyTotals.date }).from(gaDailyTotals).where(eq64(gaDailyTotals.projectId, ctx.project.id)).orderBy(desc28(gaDailyTotals.date)).limit(1).get();
     return grade(ctx, GA_SPEC, newest?.date);
   }
 };
@@ -80813,9 +81432,9 @@ var gscRecentDataCheck = {
     if (!ctx.googleConnectionStore.getConnection(ctx.project.canonicalDomain, "gsc")) {
       return skipped("gsc.data.not-connected", "Search Console is not connected for this project.");
     }
-    const watermark = ctx.db.select({ dataThroughDate: gscDataWatermarks.dataThroughDate }).from(gscDataWatermarks).where(eq61(gscDataWatermarks.projectId, ctx.project.id)).get();
+    const watermark = ctx.db.select({ dataThroughDate: gscDataWatermarks.dataThroughDate }).from(gscDataWatermarks).where(eq64(gscDataWatermarks.projectId, ctx.project.id)).get();
     if (watermark?.dataThroughDate) return grade(ctx, GSC_SPEC, watermark.dataThroughDate);
-    const newest = ctx.db.select({ date: gscDailyTotals.date }).from(gscDailyTotals).where(eq61(gscDailyTotals.projectId, ctx.project.id)).orderBy(desc28(gscDailyTotals.date)).limit(1).get();
+    const newest = ctx.db.select({ date: gscDailyTotals.date }).from(gscDailyTotals).where(eq64(gscDailyTotals.projectId, ctx.project.id)).orderBy(desc28(gscDailyTotals.date)).limit(1).get();
     return grade(ctx, GSC_SPEC, newest?.date);
   }
 };
@@ -81083,7 +81702,7 @@ var siteReachabilityCheck = {
 var SITE_REACHABILITY_CHECKS = [siteReachabilityCheck];
 
 // ../api-routes/src/doctor/checks/gbp-auth.ts
-import { and as and54, eq as eq62 } from "drizzle-orm";
+import { and as and56, eq as eq65 } from "drizzle-orm";
 var RECENT_SYNC_WARN_DAYS2 = 4;
 var RECENT_SYNC_FAIL_DAYS2 = 30;
 function skippedNoProject3() {
@@ -81316,7 +81935,7 @@ var recentSyncCheck = {
   title: "GBP recent sync",
   run: (ctx) => {
     if (!ctx.project) return skippedNoProject3();
-    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and54(eq62(gbpLocations.projectId, ctx.project.id), eq62(gbpLocations.selected, true))).all();
+    const selected = ctx.db.select({ locationName: gbpLocations.locationName, syncedAt: gbpLocations.syncedAt }).from(gbpLocations).where(and56(eq65(gbpLocations.projectId, ctx.project.id), eq65(gbpLocations.selected, true))).all();
     if (selected.length === 0) {
       return {
         status: CheckStatuses.skipped,
@@ -81376,7 +81995,7 @@ var GBP_AUTH_CHECK_BY_ID = Object.fromEntries(
 );
 
 // ../api-routes/src/doctor/checks/places.ts
-import { eq as eq63 } from "drizzle-orm";
+import { eq as eq66 } from "drizzle-orm";
 var apiKeyCheck = {
   id: "gbp.places.api-key",
   category: CheckCategories.auth,
@@ -81421,7 +82040,7 @@ var apiKeyCheck = {
         details: { tier: cfg.tier }
       };
     }
-    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq63(gbpLocations.projectId, ctx.project.id)).all();
+    const rows = ctx.db.select({ placeId: gbpLocations.placeId, selected: gbpLocations.selected }).from(gbpLocations).where(eq66(gbpLocations.projectId, ctx.project.id)).all();
     const selected = rows.filter((r) => r.selected);
     const locationsWithPlaceId = selected.filter((r) => Boolean(r.placeId)).length;
     const details = {
@@ -81963,7 +82582,7 @@ var RUNTIME_STATE_CHECKS = [
 ];
 
 // ../api-routes/src/doctor/checks/traffic-source.ts
-import { and as and55, eq as eq64, gte as gte15, inArray as inArray24, ne as ne10, sql as sql25 } from "drizzle-orm";
+import { and as and57, eq as eq67, gte as gte17, inArray as inArray25, ne as ne10, sql as sql25 } from "drizzle-orm";
 var RECENT_DATA_WARN_DAYS = 7;
 var RECENT_DATA_FAIL_DAYS = 30;
 function isCloudflareDirectPush(source) {
@@ -82002,8 +82621,8 @@ function skippedNoProject5() {
 function loadProbes(ctx) {
   if (!ctx.project) return [];
   const rows = ctx.db.select().from(trafficSources).where(
-    and55(
-      eq64(trafficSources.projectId, ctx.project.id),
+    and57(
+      eq67(trafficSources.projectId, ctx.project.id),
       ne10(trafficSources.status, TrafficSourceStatuses.archived)
     )
   ).all();
@@ -82109,28 +82728,28 @@ var recentDataCheck = {
     const failCutoff = new Date(now.getTime() - RECENT_DATA_FAIL_DAYS * 24 * 60 * 6e4).toISOString();
     const recentCrawlers = Number(
       ctx.db.select({ total: sql25`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
-        and55(
-          eq64(crawlerEventsHourly.projectId, ctx.project.id),
-          inArray24(crawlerEventsHourly.sourceId, activeSourceIds),
-          gte15(crawlerEventsHourly.tsHour, warnCutoff)
+        and57(
+          eq67(crawlerEventsHourly.projectId, ctx.project.id),
+          inArray25(crawlerEventsHourly.sourceId, activeSourceIds),
+          gte17(crawlerEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
     );
     const recentReferrals = Number(
       ctx.db.select({ total: sql25`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
-        and55(
-          eq64(aiReferralEventsHourly.projectId, ctx.project.id),
-          inArray24(aiReferralEventsHourly.sourceId, activeSourceIds),
-          gte15(aiReferralEventsHourly.tsHour, warnCutoff)
+        and57(
+          eq67(aiReferralEventsHourly.projectId, ctx.project.id),
+          inArray25(aiReferralEventsHourly.sourceId, activeSourceIds),
+          gte17(aiReferralEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
     );
     const recentUserFetches = Number(
       ctx.db.select({ total: sql25`COALESCE(SUM(${aiUserFetchEventsHourly.hits}), 0)` }).from(aiUserFetchEventsHourly).where(
-        and55(
-          eq64(aiUserFetchEventsHourly.projectId, ctx.project.id),
-          inArray24(aiUserFetchEventsHourly.sourceId, activeSourceIds),
-          gte15(aiUserFetchEventsHourly.tsHour, warnCutoff)
+        and57(
+          eq67(aiUserFetchEventsHourly.projectId, ctx.project.id),
+          inArray25(aiUserFetchEventsHourly.sourceId, activeSourceIds),
+          gte17(aiUserFetchEventsHourly.tsHour, warnCutoff)
         )
       ).get()?.total ?? 0
     );
@@ -82153,28 +82772,28 @@ var recentDataCheck = {
     }
     const olderCrawlers = Number(
       ctx.db.select({ total: sql25`COALESCE(SUM(${crawlerEventsHourly.hits}), 0)` }).from(crawlerEventsHourly).where(
-        and55(
-          eq64(crawlerEventsHourly.projectId, ctx.project.id),
-          inArray24(crawlerEventsHourly.sourceId, activeSourceIds),
-          gte15(crawlerEventsHourly.tsHour, failCutoff)
+        and57(
+          eq67(crawlerEventsHourly.projectId, ctx.project.id),
+          inArray25(crawlerEventsHourly.sourceId, activeSourceIds),
+          gte17(crawlerEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
     );
     const olderReferrals = Number(
       ctx.db.select({ total: sql25`COALESCE(SUM(${aiReferralEventsHourly.sessionsOrHits}), 0)` }).from(aiReferralEventsHourly).where(
-        and55(
-          eq64(aiReferralEventsHourly.projectId, ctx.project.id),
-          inArray24(aiReferralEventsHourly.sourceId, activeSourceIds),
-          gte15(aiReferralEventsHourly.tsHour, failCutoff)
+        and57(
+          eq67(aiReferralEventsHourly.projectId, ctx.project.id),
+          inArray25(aiReferralEventsHourly.sourceId, activeSourceIds),
+          gte17(aiReferralEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
     );
     const olderUserFetches = Number(
       ctx.db.select({ total: sql25`COALESCE(SUM(${aiUserFetchEventsHourly.hits}), 0)` }).from(aiUserFetchEventsHourly).where(
-        and55(
-          eq64(aiUserFetchEventsHourly.projectId, ctx.project.id),
-          inArray24(aiUserFetchEventsHourly.sourceId, activeSourceIds),
-          gte15(aiUserFetchEventsHourly.tsHour, failCutoff)
+        and57(
+          eq67(aiUserFetchEventsHourly.projectId, ctx.project.id),
+          inArray25(aiUserFetchEventsHourly.sourceId, activeSourceIds),
+          gte17(aiUserFetchEventsHourly.tsHour, failCutoff)
         )
       ).get()?.total ?? 0
     );
@@ -83015,6 +83634,9 @@ var ALL_CHECKS = [
   ...WORDPRESS_PUBLISH_CHECKS,
   ...GA_AUTH_CHECKS,
   ...DATA_FRESHNESS_CHECKS,
+  reportSweepsCheck,
+  reportModelsCheck,
+  reportDailyDataCheck,
   ...ADS_CHECKS,
   ...GOOGLE_MARKETING_DOCTOR_CHECKS,
   ...PROVIDERS_CHECKS,
@@ -83025,6 +83647,9 @@ var ALL_CHECKS = [
   // Network probe last, so a slow or unreachable site never delays the local checks.
   ...SITE_REACHABILITY_CHECKS
 ];
+function scheduledHealthCheckIds() {
+  return ALL_CHECKS.filter((check2) => check2.scope === CheckScopes.project && !check2.optIn && check2.notificationPolicy !== CheckNotificationPolicies.silent).map((check2) => check2.id);
+}
 
 // ../api-routes/src/doctor/runner.ts
 function matchesCheckId(checkId, filters) {
@@ -83057,7 +83682,9 @@ async function runChecks(ctx, checks, options = {}) {
     } catch (err) {
       const message = describeError(err);
       output = {
-        status: CheckStatuses.fail,
+        // An advisory that cannot run is still only an advisory: it must not
+        // fail the doctor (and its exit code) the way a broken health check does.
+        status: definition.notificationPolicy === CheckNotificationPolicies.silent ? CheckStatuses.warn : CheckStatuses.fail,
         code: `${definition.id}.runtime-error`,
         summary: `Check threw an unexpected error: ${message}`,
         remediation: null,
@@ -83070,6 +83697,7 @@ async function runChecks(ctx, checks, options = {}) {
       scope: definition.scope,
       title: definition.title,
       status: output.status,
+      ...definition.notificationPolicy ? { notificationPolicy: definition.notificationPolicy } : {},
       code: output.code,
       summary: output.summary,
       remediation: output.remediation ?? null,
@@ -83080,6 +83708,7 @@ async function runChecks(ctx, checks, options = {}) {
   return {
     scope: targetScope,
     project: projectName,
+    ...ctx.project ? { reportMonths: reportMonthsForDoctor(ctx.reportMonth, startedAt) } : {},
     generatedAt: startedAt.toISOString(),
     durationMs: Date.now() - startedAt.getTime(),
     summary: summarizeCheckResults(results),
@@ -83088,6 +83717,12 @@ async function runChecks(ctx, checks, options = {}) {
 }
 
 // ../api-routes/src/doctor.ts
+function parseReportMonth(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = reportMonthSchema.safeParse(raw);
+  if (!parsed.success || raw > (/* @__PURE__ */ new Date()).toISOString().slice(0, 7)) throw validationError('"reportMonth" must be YYYY-MM and cannot be in the future');
+  return parsed.data;
+}
 function parseCheckIds(raw) {
   if (!raw) return [];
   return raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
@@ -83102,6 +83737,7 @@ async function doctorRoutes(app, opts) {
     const checkIds = parseCheckIds(request.query.check);
     const ctx = {
       db: app.db,
+      reportMonth: parseReportMonth(request.query.reportMonth),
       project: null,
       googleConnectionStore: opts.googleConnectionStore,
       bingConnectionStore: opts.bingConnectionStore,
@@ -83129,6 +83765,7 @@ async function doctorRoutes(app, opts) {
     const checkIds = parseCheckIds(request.query.check);
     const ctx = {
       db: app.db,
+      reportMonth: parseReportMonth(request.query.reportMonth),
       project: {
         id: project.id,
         name: project.name,
@@ -83160,7 +83797,7 @@ async function doctorRoutes(app, opts) {
 
 // ../api-routes/src/discovery/routes.ts
 import crypto47 from "crypto";
-import { and as and56, desc as desc29, eq as eq65, gte as gte16, inArray as inArray25, isNull as isNull11, or as or15 } from "drizzle-orm";
+import { and as and58, desc as desc29, eq as eq68, gte as gte18, inArray as inArray26, isNull as isNull11, or as or15 } from "drizzle-orm";
 var MAX_INFLIGHT_DISCOVERY_AGE_MS = 2 * 60 * 60 * 1e3;
 async function discoveryRoutes(app, opts) {
   app.post("/projects/:name/discover/run", async (request, reply) => {
@@ -83194,13 +83831,13 @@ async function discoveryRoutes(app, opts) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const ageFloorIso = new Date(Date.now() - MAX_INFLIGHT_DISCOVERY_AGE_MS).toISOString();
     const decision = app.db.transaction((tx) => {
-      const existing = tx.select({ id: discoverySessions.id, runId: discoverySessions.runId }).from(discoverySessions).where(and56(
-        eq65(discoverySessions.projectId, project.id),
-        eq65(discoverySessions.icpDescription, icpDescription),
+      const existing = tx.select({ id: discoverySessions.id, runId: discoverySessions.runId }).from(discoverySessions).where(and58(
+        eq68(discoverySessions.projectId, project.id),
+        eq68(discoverySessions.icpDescription, icpDescription),
         // Buyer is part of session identity: it changes the seed prompt's
         // semantics, so a request with a different (or no) buyer must start
         // its own session, never adopt another buyer's probes.
-        parsed.data.buyerDescription == null ? isNull11(discoverySessions.buyerDescription) : eq65(discoverySessions.buyerDescription, parsed.data.buyerDescription),
+        parsed.data.buyerDescription == null ? isNull11(discoverySessions.buyerDescription) : eq68(discoverySessions.buyerDescription, parsed.data.buyerDescription),
         // Locations are identity too: a different service-area subset seeds
         // and probes a different geo, so it must never reuse another geo's
         // session. resolveLocations is deterministic (project-config order),
@@ -83210,17 +83847,17 @@ async function discoveryRoutes(app, opts) {
         // locations a NULL row's subset is unknowable, so it conservatively
         // never reuses — a one-time, bounded (2h window) non-reuse after
         // upgrade, never a wrong reuse.
-        locations.length === 0 ? or15(isNull11(discoverySessions.locations), eq65(discoverySessions.locations, locations)) : eq65(discoverySessions.locations, locations),
+        locations.length === 0 ? or15(isNull11(discoverySessions.locations), eq68(discoverySessions.locations, locations)) : eq68(discoverySessions.locations, locations),
         // Seed provider set is identity: a different phrasing distribution
         // must never reuse another set's session. Null (= Gemini-only
         // default, including explicit ['gemini']) matches legacy rows.
-        seedProviders == null ? isNull11(discoverySessions.seedProviders) : eq65(discoverySessions.seedProviders, seedProviders),
-        inArray25(discoverySessions.status, [
+        seedProviders == null ? isNull11(discoverySessions.seedProviders) : eq68(discoverySessions.seedProviders, seedProviders),
+        inArray26(discoverySessions.status, [
           DiscoverySessionStatuses.queued,
           DiscoverySessionStatuses.seeding,
           DiscoverySessionStatuses.probing
         ]),
-        gte16(discoverySessions.createdAt, ageFloorIso)
+        gte18(discoverySessions.createdAt, ageFloorIso)
       )).orderBy(desc29(discoverySessions.createdAt)).get();
       if (existing && existing.runId) {
         return { reused: true, sessionId: existing.id, runId: existing.runId };
@@ -83290,7 +83927,7 @@ async function discoveryRoutes(app, opts) {
       const project = resolveProject(app.db, request.params.name);
       const parsedLimit = parseInt(request.query.limit ?? "", 10);
       const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? 50 : parsedLimit;
-      const rows = app.db.select().from(discoverySessions).where(eq65(discoverySessions.projectId, project.id)).orderBy(desc29(discoverySessions.createdAt)).limit(limit).all();
+      const rows = app.db.select().from(discoverySessions).where(eq68(discoverySessions.projectId, project.id)).orderBy(desc29(discoverySessions.createdAt)).limit(limit).all();
       return reply.send(rows.map(serializeSession));
     }
   );
@@ -83298,11 +83935,11 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq65(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq68(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq65(discoveryProbes.sessionId, session.id)).all();
+      const probeRows = app.db.select().from(discoveryProbes).where(eq68(discoveryProbes.sessionId, session.id)).all();
       const detail = {
         ...serializeSession(session),
         probes: probeRows.map(serializeProbe)
@@ -83314,7 +83951,7 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id/harvest",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq65(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq68(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
@@ -83322,7 +83959,7 @@ async function discoveryRoutes(app, opts) {
       const minProbeHits = Number.isNaN(parsedFloor) || parsedFloor < 1 ? 1 : parsedFloor;
       const applyAnchor = request.query.anchor !== "false";
       const provider = session.seedProvider ?? "gemini";
-      const probeRows = app.db.select().from(discoveryProbes).where(eq65(discoveryProbes.sessionId, session.id)).all();
+      const probeRows = app.db.select().from(discoveryProbes).where(eq68(discoveryProbes.sessionId, session.id)).all();
       const extract = opts.harvestSearchQueries;
       const probesWithQueries = probeRows.map((row) => {
         if (!extract || !row.rawResponse) return { searchQueries: [] };
@@ -83333,7 +83970,7 @@ async function discoveryRoutes(app, opts) {
           return { searchQueries: [] };
         }
       });
-      const trackedQueries = app.db.select({ query: queries.query }).from(queries).where(eq65(queries.projectId, project.id)).all().map((r) => r.query);
+      const trackedQueries = app.db.select({ query: queries.query }).from(queries).where(eq68(queries.projectId, project.id)).all().map((r) => r.query);
       const anchorTerms = buildHarvestAnchorTerms(
         [session.icpDescription ?? "", ...trackedQueries],
         effectiveDomains(project)
@@ -83380,12 +84017,12 @@ async function discoveryRoutes(app, opts) {
     "/projects/:name/discover/sessions/:id/promote",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const session = app.db.select().from(discoverySessions).where(eq65(discoverySessions.id, request.params.id)).get();
+      const session = app.db.select().from(discoverySessions).where(eq68(discoverySessions.id, request.params.id)).get();
       if (!session || session.projectId !== project.id) {
         throw notFound("Discovery session", request.params.id);
       }
-      const probeRows = app.db.select().from(discoveryProbes).where(eq65(discoveryProbes.sessionId, session.id)).all();
-      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq65(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
+      const probeRows = app.db.select().from(discoveryProbes).where(eq68(discoveryProbes.sessionId, session.id)).all();
+      const existingCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq68(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase());
       const seenCompetitors = new Set(existingCompetitors);
       const cited = /* @__PURE__ */ new Set();
       const aspirational = /* @__PURE__ */ new Set();
@@ -83414,7 +84051,7 @@ async function discoveryRoutes(app, opts) {
   );
   app.post("/projects/:name/discover/sessions/:id/promote", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const session = app.db.select().from(discoverySessions).where(eq65(discoverySessions.id, request.params.id)).get();
+    const session = app.db.select().from(discoverySessions).where(eq68(discoverySessions.id, request.params.id)).get();
     if (!session || session.projectId !== project.id) {
       throw notFound("Discovery session", request.params.id);
     }
@@ -83437,7 +84074,7 @@ async function discoveryRoutes(app, opts) {
     const bucketSet = new Set(buckets);
     const includeCompetitors = parsed.data.includeCompetitors ?? true;
     const competitorTypes = parsed.data.competitorTypes ?? DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES;
-    const probeRows = app.db.select().from(discoveryProbes).where(eq65(discoveryProbes.sessionId, session.id)).all();
+    const probeRows = app.db.select().from(discoveryProbes).where(eq68(discoveryProbes.sessionId, session.id)).all();
     const candidateQueries = /* @__PURE__ */ new Set();
     for (const probe of probeRows) {
       if (!probe.bucket) continue;
@@ -83445,7 +84082,7 @@ async function discoveryRoutes(app, opts) {
       if (bucket.success && bucketSet.has(bucket.data)) candidateQueries.add(probe.query);
     }
     const existingQueries = new Set(
-      app.db.select({ query: queries.query }).from(queries).where(eq65(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
+      app.db.select({ query: queries.query }).from(queries).where(eq68(queries.projectId, project.id)).all().map((r) => r.query.toLowerCase())
     );
     const promotedQueries = [];
     const skippedQueries = [];
@@ -83461,7 +84098,7 @@ async function discoveryRoutes(app, opts) {
     const skippedCompetitors = [];
     if (includeCompetitors) {
       const existingCompetitors = new Set(
-        app.db.select({ domain: competitors.domain }).from(competitors).where(eq65(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
+        app.db.select({ domain: competitors.domain }).from(competitors).where(eq68(competitors.projectId, project.id)).all().map((r) => r.domain.toLowerCase())
       );
       const competitorMap = parseCompetitorMap(session.competitorMap);
       for (const entry of selectEligibleCompetitors(competitorMap, competitorTypes)) {
@@ -83580,7 +84217,7 @@ function selectEligibleCompetitors(competitorMap, competitorTypes) {
 
 // ../api-routes/src/discovery/orchestrate.ts
 import crypto48 from "crypto";
-import { eq as eq66 } from "drizzle-orm";
+import { eq as eq69 } from "drizzle-orm";
 var DEFAULT_MAX_PROBES = 100;
 var ABSOLUTE_MAX_PROBES = 500;
 function classifyProbeBucket(input) {
@@ -83667,7 +84304,7 @@ async function executeDiscovery(opts) {
     status: DiscoverySessionStatuses.seeding,
     dedupThreshold,
     startedAt
-  }).where(eq66(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq69(discoverySessions.id, opts.sessionId)).run();
   const seedResult = await opts.deps.seed({
     project: opts.project,
     icpDescription: opts.icpDescription,
@@ -83728,7 +84365,7 @@ async function executeDiscovery(opts) {
     dedupBandPairFraction: dedupStats.bandPairFraction,
     dedupPairsTotal: dedupStats.pairsTotal,
     warning
-  }).where(eq66(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq69(discoverySessions.id, opts.sessionId)).run();
   const probeLocation = opts.locations?.[0];
   const probeResults = await mapWithConcurrency(
     probedCanonicals,
@@ -83782,7 +84419,7 @@ async function executeDiscovery(opts) {
     wastedCount: buckets["wasted-surface"],
     competitorMap,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq66(discoverySessions.id, opts.sessionId)).run();
+  }).where(eq69(discoverySessions.id, opts.sessionId)).run();
   upsertDomainClassifications(opts.db, opts.project.id, opts.sessionId, competitorMap);
   return {
     buckets,
@@ -83822,7 +84459,7 @@ function markSessionFailed(db, sessionId, error) {
     status: DiscoverySessionStatuses.failed,
     error,
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
-  }).where(eq66(discoverySessions.id, sessionId)).run();
+  }).where(eq69(discoverySessions.id, sessionId)).run();
 }
 function dedupeStrings(input) {
   const seen2 = /* @__PURE__ */ new Set();
@@ -83840,7 +84477,7 @@ function dedupeStrings(input) {
 
 // ../api-routes/src/technical-aeo.ts
 import crypto49 from "crypto";
-import { and as and57, asc as asc11, count as count2, desc as desc30, eq as eq67, inArray as inArray26, isNotNull as isNotNull5, isNull as isNull12, lt as lt11, or as or16, sql as sql26 } from "drizzle-orm";
+import { and as and59, asc as asc12, count as count2, desc as desc30, eq as eq70, inArray as inArray27, isNotNull as isNotNull5, isNull as isNull12, lt as lt11, or as or16, sql as sql26 } from "drizzle-orm";
 import { alias } from "drizzle-orm/sqlite-core";
 var FETCHED_SITE_CRAWL_STATES = /* @__PURE__ */ new Set([
   ...SiteCrawlFetchedStates,
@@ -84053,8 +84690,8 @@ function parseLinkKind(value) {
   return allowed.data;
 }
 function linkKindFilter(linkKind) {
-  if (linkKind === SiteHealthLinkKinds.content) return eq67(siteCrawlEdges.isTemplate, false);
-  if (linkKind === SiteHealthLinkKinds.template) return eq67(siteCrawlEdges.isTemplate, true);
+  if (linkKind === SiteHealthLinkKinds.content) return eq70(siteCrawlEdges.isTemplate, false);
+  if (linkKind === SiteHealthLinkKinds.template) return eq70(siteCrawlEdges.isTemplate, true);
   return void 0;
 }
 var graphSourceNode = alias(siteCrawlGraphNodes, "site_crawl_graph_source_node");
@@ -84159,50 +84796,50 @@ function changedFields(before, after, fields) {
 async function technicalAeoRoutes(app, opts) {
   const resolveCrawl = (projectId, runId) => {
     const filters = [
-      eq67(siteCrawlSnapshots.projectId, projectId),
-      eq67(runs.projectId, projectId),
-      eq67(runs.kind, RunKinds["site-audit"]),
-      inArray26(runs.status, SURFACEABLE_STATUSES),
+      eq70(siteCrawlSnapshots.projectId, projectId),
+      eq70(runs.projectId, projectId),
+      eq70(runs.kind, RunKinds["site-audit"]),
+      inArray27(runs.status, SURFACEABLE_STATUSES),
       notProbeRun()
     ];
     if (runId) {
-      filters.push(eq67(siteCrawlSnapshots.runId, runId));
+      filters.push(eq70(siteCrawlSnapshots.runId, runId));
     } else {
-      filters.push(eq67(siteCrawlSnapshots.complete, true), eq67(runs.status, RunStatuses.completed));
+      filters.push(eq70(siteCrawlSnapshots.complete, true), eq70(runs.status, RunStatuses.completed));
     }
-    return app.db.select({ snapshot: siteCrawlSnapshots, runStatus: runs.status }).from(siteCrawlSnapshots).innerJoin(runs, eq67(siteCrawlSnapshots.runId, runs.id)).where(and57(...filters)).orderBy(desc30(siteCrawlSnapshots.createdAt), desc30(siteCrawlSnapshots.runId)).limit(1).get();
+    return app.db.select({ snapshot: siteCrawlSnapshots, runStatus: runs.status }).from(siteCrawlSnapshots).innerJoin(runs, eq70(siteCrawlSnapshots.runId, runs.id)).where(and59(...filters)).orderBy(desc30(siteCrawlSnapshots.createdAt), desc30(siteCrawlSnapshots.runId)).limit(1).get();
   };
   const detailScopeFor = (projectId, snapshot) => snapshot.detailsAvailable && snapshot.attemptId ? { projectId, runId: snapshot.runId, attemptId: snapshot.attemptId } : null;
   const pageInScope = (scope, selector) => {
     if (!selector.nodeKey && !selector.url) return null;
-    return app.db.select().from(siteCrawlPages).where(and57(
-      eq67(siteCrawlPages.projectId, scope.projectId),
-      eq67(siteCrawlPages.runId, scope.runId),
-      eq67(siteCrawlPages.attemptId, scope.attemptId),
-      selector.nodeKey ? eq67(siteCrawlPages.nodeKey, selector.nodeKey) : eq67(siteCrawlPages.url, selector.url)
-    )).orderBy(asc11(siteCrawlPages.nodeKey)).limit(1).get() ?? null;
+    return app.db.select().from(siteCrawlPages).where(and59(
+      eq70(siteCrawlPages.projectId, scope.projectId),
+      eq70(siteCrawlPages.runId, scope.runId),
+      eq70(siteCrawlPages.attemptId, scope.attemptId),
+      selector.nodeKey ? eq70(siteCrawlPages.nodeKey, selector.nodeKey) : eq70(siteCrawlPages.url, selector.url)
+    )).orderBy(asc12(siteCrawlPages.nodeKey)).limit(1).get() ?? null;
   };
-  const rootPageInScope = (scope, rootUrl) => pageInScope(scope, { url: rootUrl }) ?? app.db.select().from(siteCrawlPages).where(and57(
-    eq67(siteCrawlPages.projectId, scope.projectId),
-    eq67(siteCrawlPages.runId, scope.runId),
-    eq67(siteCrawlPages.attemptId, scope.attemptId),
-    eq67(siteCrawlPages.depth, 0)
-  )).orderBy(asc11(siteCrawlPages.nodeKey)).limit(1).get() ?? null;
-  const isSurfaceableAuditRun = (projectId, runId) => Boolean(app.db.select({ id: runs.id }).from(runs).where(and57(
-    eq67(runs.id, runId),
-    eq67(runs.projectId, projectId),
-    eq67(runs.kind, RunKinds["site-audit"]),
-    inArray26(runs.status, SURFACEABLE_STATUSES),
+  const rootPageInScope = (scope, rootUrl) => pageInScope(scope, { url: rootUrl }) ?? app.db.select().from(siteCrawlPages).where(and59(
+    eq70(siteCrawlPages.projectId, scope.projectId),
+    eq70(siteCrawlPages.runId, scope.runId),
+    eq70(siteCrawlPages.attemptId, scope.attemptId),
+    eq70(siteCrawlPages.depth, 0)
+  )).orderBy(asc12(siteCrawlPages.nodeKey)).limit(1).get() ?? null;
+  const isSurfaceableAuditRun = (projectId, runId) => Boolean(app.db.select({ id: runs.id }).from(runs).where(and59(
+    eq70(runs.id, runId),
+    eq70(runs.projectId, projectId),
+    eq70(runs.kind, RunKinds["site-audit"]),
+    inArray27(runs.status, SURFACEABLE_STATUSES),
     notProbeRun()
   )).limit(1).get());
   const assertKnownAuditRun = (projectId, runId) => {
     if (runId && !isSurfaceableAuditRun(projectId, runId)) throw notFound("Site crawl run", runId);
   };
-  const hasLegacyAudit = (projectId) => Boolean(app.db.select({ runId: siteAuditSnapshots.runId }).from(siteAuditSnapshots).innerJoin(runs, eq67(siteAuditSnapshots.runId, runs.id)).where(and57(
-    eq67(siteAuditSnapshots.projectId, projectId),
-    eq67(runs.projectId, projectId),
-    eq67(runs.kind, RunKinds["site-audit"]),
-    inArray26(runs.status, SURFACEABLE_STATUSES),
+  const hasLegacyAudit = (projectId) => Boolean(app.db.select({ runId: siteAuditSnapshots.runId }).from(siteAuditSnapshots).innerJoin(runs, eq70(siteAuditSnapshots.runId, runs.id)).where(and59(
+    eq70(siteAuditSnapshots.projectId, projectId),
+    eq70(runs.projectId, projectId),
+    eq70(runs.kind, RunKinds["site-audit"]),
+    inArray27(runs.status, SURFACEABLE_STATUSES),
     notProbeRun()
   )).limit(1).get());
   const emptyCrawlSummary = (projectName, legacyAuditAvailable) => ({
@@ -84223,20 +84860,20 @@ async function technicalAeoRoutes(app, opts) {
   app.get("/projects/:name/technical-aeo", async (request) => {
     const project = resolveProject(app.db, request.params.name);
     const baseFilters = [
-      eq67(siteAuditSnapshots.projectId, project.id),
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
-      inArray26(runs.status, SURFACEABLE_STATUSES),
+      eq70(siteAuditSnapshots.projectId, project.id),
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
+      inArray27(runs.status, SURFACEABLE_STATUSES),
       notProbeRun()
     ];
-    const targetFilters = request.query.runId ? [...baseFilters, eq67(siteAuditSnapshots.runId, request.query.runId)] : baseFilters;
-    const latest = app.db.select({ snap: siteAuditSnapshots, runStatus: runs.status }).from(siteAuditSnapshots).innerJoin(runs, eq67(siteAuditSnapshots.runId, runs.id)).where(and57(...targetFilters)).orderBy(desc30(siteAuditSnapshots.createdAt)).limit(1).get();
+    const targetFilters = request.query.runId ? [...baseFilters, eq70(siteAuditSnapshots.runId, request.query.runId)] : baseFilters;
+    const latest = app.db.select({ snap: siteAuditSnapshots, runStatus: runs.status }).from(siteAuditSnapshots).innerJoin(runs, eq70(siteAuditSnapshots.runId, runs.id)).where(and59(...targetFilters)).orderBy(desc30(siteAuditSnapshots.createdAt)).limit(1).get();
     if (!latest) {
       if (request.query.runId) throw notFound("Site audit run", request.query.runId);
       return emptyScore(project.name);
     }
     const snap = latest.snap;
-    const previous = app.db.select({ snap: siteAuditSnapshots }).from(siteAuditSnapshots).innerJoin(runs, eq67(siteAuditSnapshots.runId, runs.id)).where(and57(...baseFilters, lt11(siteAuditSnapshots.createdAt, snap.createdAt))).orderBy(desc30(siteAuditSnapshots.createdAt)).limit(1).get()?.snap ?? null;
+    const previous = app.db.select({ snap: siteAuditSnapshots }).from(siteAuditSnapshots).innerJoin(runs, eq70(siteAuditSnapshots.runId, runs.id)).where(and59(...baseFilters, lt11(siteAuditSnapshots.createdAt, snap.createdAt))).orderBy(desc30(siteAuditSnapshots.createdAt)).limit(1).get()?.snap ?? null;
     const deltaScore = previous ? snap.aggregateScore - previous.aggregateScore : null;
     const trend = deltaScore == null ? null : deltaScore > 0 ? SiteAuditTrendDirections.up : deltaScore < 0 ? SiteAuditTrendDirections.down : SiteAuditTrendDirections.flat;
     return {
@@ -84263,14 +84900,14 @@ async function technicalAeoRoutes(app, opts) {
   app.get("/projects/:name/technical-aeo/pages", async (request) => {
     const project = resolveProject(app.db, request.params.name);
     const targetFilters = [
-      eq67(siteAuditSnapshots.projectId, project.id),
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
-      inArray26(runs.status, SURFACEABLE_STATUSES),
+      eq70(siteAuditSnapshots.projectId, project.id),
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
+      inArray27(runs.status, SURFACEABLE_STATUSES),
       notProbeRun()
     ];
-    if (request.query.runId) targetFilters.push(eq67(siteAuditSnapshots.runId, request.query.runId));
-    const latest = app.db.select({ runId: siteAuditSnapshots.runId, auditedAt: siteAuditSnapshots.auditedAt }).from(siteAuditSnapshots).innerJoin(runs, eq67(siteAuditSnapshots.runId, runs.id)).where(and57(...targetFilters)).orderBy(desc30(siteAuditSnapshots.createdAt)).limit(1).get();
+    if (request.query.runId) targetFilters.push(eq70(siteAuditSnapshots.runId, request.query.runId));
+    const latest = app.db.select({ runId: siteAuditSnapshots.runId, auditedAt: siteAuditSnapshots.auditedAt }).from(siteAuditSnapshots).innerJoin(runs, eq70(siteAuditSnapshots.runId, runs.id)).where(and59(...targetFilters)).orderBy(desc30(siteAuditSnapshots.createdAt)).limit(1).get();
     if (!latest && request.query.runId) {
       throw notFound("Site audit run", request.query.runId);
     }
@@ -84278,14 +84915,14 @@ async function technicalAeoRoutes(app, opts) {
       return { project: project.name, runId: null, auditedAt: null, total: 0, pages: [] };
     }
     const statusFilter = request.query.status === "success" || request.query.status === "error" ? request.query.status : null;
-    const conds = [eq67(siteAuditPages.projectId, project.id), eq67(siteAuditPages.runId, latest.runId)];
-    if (statusFilter) conds.push(eq67(siteAuditPages.status, statusFilter));
-    const where = and57(...conds);
+    const conds = [eq70(siteAuditPages.projectId, project.id), eq70(siteAuditPages.runId, latest.runId)];
+    if (statusFilter) conds.push(eq70(siteAuditPages.status, statusFilter));
+    const where = and59(...conds);
     const totalRow = app.db.select({ value: count2() }).from(siteAuditPages).where(where).get();
     const total = totalRow?.value ?? 0;
     const limit = parsePositiveInt(request.query.limit, 100, 500);
     const offset = parsePositiveInt(request.query.offset, 0, Number.MAX_SAFE_INTEGER);
-    const orderBy = request.query.sort === "score-desc" ? desc30(siteAuditPages.overallScore) : request.query.sort === "url" ? asc11(siteAuditPages.url) : asc11(siteAuditPages.overallScore);
+    const orderBy = request.query.sort === "score-desc" ? desc30(siteAuditPages.overallScore) : request.query.sort === "url" ? asc12(siteAuditPages.url) : asc12(siteAuditPages.overallScore);
     const rows = app.db.select().from(siteAuditPages).where(where).orderBy(orderBy).limit(limit).offset(offset).all();
     const pages = rows.map((row) => ({
       url: row.url,
@@ -84304,11 +84941,11 @@ async function technicalAeoRoutes(app, opts) {
       auditedAt: siteAuditSnapshots.auditedAt,
       aggregateScore: siteAuditSnapshots.aggregateScore,
       pagesAudited: siteAuditSnapshots.pagesAudited
-    }).from(siteAuditSnapshots).innerJoin(runs, eq67(siteAuditSnapshots.runId, runs.id)).where(and57(
-      eq67(siteAuditSnapshots.projectId, project.id),
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
-      inArray26(runs.status, SURFACEABLE_STATUSES),
+    }).from(siteAuditSnapshots).innerJoin(runs, eq70(siteAuditSnapshots.runId, runs.id)).where(and59(
+      eq70(siteAuditSnapshots.projectId, project.id),
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
+      inArray27(runs.status, SURFACEABLE_STATUSES),
       notProbeRun()
     )).orderBy(desc30(siteAuditSnapshots.createdAt)).limit(limit).all();
     return { project: project.name, points: rows.reverse() };
@@ -84402,10 +85039,10 @@ async function technicalAeoRoutes(app, opts) {
       { projectId: project.id, runId: snapshot.runId, attemptId: snapshot.attemptId },
       snapshot.rootUrl
     )?.nodeKey ?? null;
-    const persistedLayout = app.db.select().from(siteCrawlGraphLayouts).where(and57(
-      eq67(siteCrawlGraphLayouts.projectId, project.id),
-      eq67(siteCrawlGraphLayouts.runId, snapshot.runId),
-      eq67(siteCrawlGraphLayouts.attemptId, snapshot.attemptId)
+    const persistedLayout = app.db.select().from(siteCrawlGraphLayouts).where(and59(
+      eq70(siteCrawlGraphLayouts.projectId, project.id),
+      eq70(siteCrawlGraphLayouts.runId, snapshot.runId),
+      eq70(siteCrawlGraphLayouts.attemptId, snapshot.attemptId)
     )).limit(1).get();
     if (!persistedLayout) {
       return {
@@ -84456,9 +85093,9 @@ async function technicalAeoRoutes(app, opts) {
     const maxNodes = parseBoundedLimit(request.query.maxNodes, SITE_CRAWL_GRAPH_DEFAULT_MAX_NODES, SITE_CRAWL_GRAPH_MAX_NODES);
     const maxEdges = parseBoundedLimit(request.query.maxEdges, SITE_CRAWL_GRAPH_DEFAULT_MAX_EDGES, SITE_CRAWL_GRAPH_MAX_EDGES);
     const graphScope = [
-      eq67(siteCrawlGraphNodes.projectId, project.id),
-      eq67(siteCrawlGraphNodes.runId, snapshot.runId),
-      eq67(siteCrawlGraphNodes.attemptId, snapshot.attemptId)
+      eq70(siteCrawlGraphNodes.projectId, project.id),
+      eq70(siteCrawlGraphNodes.runId, snapshot.runId),
+      eq70(siteCrawlGraphNodes.attemptId, snapshot.attemptId)
     ];
     const nodeRows = app.db.select({
       nodeKey: siteCrawlPages.nodeKey,
@@ -84477,17 +85114,17 @@ async function technicalAeoRoutes(app, opts) {
       linkScoreNormalized: siteCrawlPages.linkScoreNormalized,
       x: siteCrawlGraphNodes.x,
       y: siteCrawlGraphNodes.y
-    }).from(siteCrawlGraphNodes).innerJoin(siteCrawlPages, and57(
-      eq67(siteCrawlPages.projectId, siteCrawlGraphNodes.projectId),
-      eq67(siteCrawlPages.runId, siteCrawlGraphNodes.runId),
-      eq67(siteCrawlPages.attemptId, siteCrawlGraphNodes.attemptId),
-      eq67(siteCrawlPages.nodeKey, siteCrawlGraphNodes.nodeKey)
-    )).where(and57(...graphScope, lt11(siteCrawlGraphNodes.sampleRank, maxNodes))).orderBy(asc11(siteCrawlGraphNodes.sampleRank)).all();
+    }).from(siteCrawlGraphNodes).innerJoin(siteCrawlPages, and59(
+      eq70(siteCrawlPages.projectId, siteCrawlGraphNodes.projectId),
+      eq70(siteCrawlPages.runId, siteCrawlGraphNodes.runId),
+      eq70(siteCrawlPages.attemptId, siteCrawlGraphNodes.attemptId),
+      eq70(siteCrawlPages.nodeKey, siteCrawlGraphNodes.nodeKey)
+    )).where(and59(...graphScope, lt11(siteCrawlGraphNodes.sampleRank, maxNodes))).orderBy(asc12(siteCrawlGraphNodes.sampleRank)).all();
     const nodes = nodeRows.map(({ indexabilityReasons, canonicalNodeKey, ...row }) => ({
       ...row,
       healthState: deriveSiteHealthState({ ...row, indexabilityReasons, canonicalNodeKey })
     }));
-    const graphLinkKindFilter = linkKind === SiteHealthLinkKinds.all ? void 0 : eq67(siteCrawlGraphEdges.isTemplate, linkKind === SiteHealthLinkKinds.template);
+    const graphLinkKindFilter = linkKind === SiteHealthLinkKinds.all ? void 0 : eq70(siteCrawlGraphEdges.isTemplate, linkKind === SiteHealthLinkKinds.template);
     const edges = app.db.select({
       edgeKey: siteCrawlGraphEdges.edgeKey,
       sourceNodeKey: siteCrawlGraphEdges.sourceNodeKey,
@@ -84495,25 +85132,25 @@ async function technicalAeoRoutes(app, opts) {
       followable: siteCrawlGraphEdges.followable,
       occurrences: siteCrawlGraphEdges.occurrences,
       isTemplate: siteCrawlGraphEdges.isTemplate
-    }).from(siteCrawlGraphEdges).innerJoin(graphSourceNode, and57(
-      eq67(graphSourceNode.projectId, siteCrawlGraphEdges.projectId),
-      eq67(graphSourceNode.runId, siteCrawlGraphEdges.runId),
-      eq67(graphSourceNode.attemptId, siteCrawlGraphEdges.attemptId),
-      eq67(graphSourceNode.nodeKey, siteCrawlGraphEdges.sourceNodeKey),
+    }).from(siteCrawlGraphEdges).innerJoin(graphSourceNode, and59(
+      eq70(graphSourceNode.projectId, siteCrawlGraphEdges.projectId),
+      eq70(graphSourceNode.runId, siteCrawlGraphEdges.runId),
+      eq70(graphSourceNode.attemptId, siteCrawlGraphEdges.attemptId),
+      eq70(graphSourceNode.nodeKey, siteCrawlGraphEdges.sourceNodeKey),
       lt11(graphSourceNode.sampleRank, maxNodes)
-    )).innerJoin(graphTargetNode, and57(
-      eq67(graphTargetNode.projectId, siteCrawlGraphEdges.projectId),
-      eq67(graphTargetNode.runId, siteCrawlGraphEdges.runId),
-      eq67(graphTargetNode.attemptId, siteCrawlGraphEdges.attemptId),
-      eq67(graphTargetNode.nodeKey, siteCrawlGraphEdges.targetNodeKey),
+    )).innerJoin(graphTargetNode, and59(
+      eq70(graphTargetNode.projectId, siteCrawlGraphEdges.projectId),
+      eq70(graphTargetNode.runId, siteCrawlGraphEdges.runId),
+      eq70(graphTargetNode.attemptId, siteCrawlGraphEdges.attemptId),
+      eq70(graphTargetNode.nodeKey, siteCrawlGraphEdges.targetNodeKey),
       lt11(graphTargetNode.sampleRank, maxNodes)
-    )).where(and57(
-      eq67(siteCrawlGraphEdges.projectId, project.id),
-      eq67(siteCrawlGraphEdges.runId, snapshot.runId),
-      eq67(siteCrawlGraphEdges.attemptId, snapshot.attemptId),
+    )).where(and59(
+      eq70(siteCrawlGraphEdges.projectId, project.id),
+      eq70(siteCrawlGraphEdges.runId, snapshot.runId),
+      eq70(siteCrawlGraphEdges.attemptId, snapshot.attemptId),
       lt11(siteCrawlGraphEdges.sampleRank, maxEdges),
       graphLinkKindFilter
-    )).orderBy(asc11(siteCrawlGraphEdges.sampleRank)).all();
+    )).orderBy(asc12(siteCrawlGraphEdges.sampleRank)).all();
     const totalNodes = persistedLayout.totalNodes;
     const totalEdges = persistedLayout.totalEdges;
     const totalTemplateEdges = persistedLayout.totalTemplateEdges;
@@ -84604,17 +85241,17 @@ async function technicalAeoRoutes(app, opts) {
     let frontier = [focus.nodeKey];
     let queryTruncated = false;
     for (let distance = 0; distance < hops && frontier.length > 0; distance += 1) {
-      const candidates = app.db.select().from(siteCrawlEdges).where(and57(
-        eq67(siteCrawlEdges.projectId, scope.projectId),
-        eq67(siteCrawlEdges.runId, scope.runId),
-        eq67(siteCrawlEdges.attemptId, scope.attemptId),
-        eq67(siteCrawlEdges.internal, true),
+      const candidates = app.db.select().from(siteCrawlEdges).where(and59(
+        eq70(siteCrawlEdges.projectId, scope.projectId),
+        eq70(siteCrawlEdges.runId, scope.runId),
+        eq70(siteCrawlEdges.attemptId, scope.attemptId),
+        eq70(siteCrawlEdges.internal, true),
         isNotNull5(siteCrawlEdges.targetNodeKey),
         or16(
-          inArray26(siteCrawlEdges.sourceNodeKey, frontier),
-          inArray26(siteCrawlEdges.targetNodeKey, frontier)
+          inArray27(siteCrawlEdges.sourceNodeKey, frontier),
+          inArray27(siteCrawlEdges.targetNodeKey, frontier)
         )
-      )).orderBy(asc11(siteCrawlEdges.edgeKey)).limit(maxEdges + maxNodes + 1).all();
+      )).orderBy(asc12(siteCrawlEdges.edgeKey)).limit(maxEdges + maxNodes + 1).all();
       if (candidates.length > maxEdges + maxNodes) queryTruncated = true;
       const next = /* @__PURE__ */ new Set();
       for (const edge of candidates.slice(0, maxEdges + maxNodes)) {
@@ -84645,22 +85282,22 @@ async function technicalAeoRoutes(app, opts) {
       frontier = [...next].sort();
     }
     const nodeKeys = [...distances.keys()];
-    const pageRows = nodeKeys.length === 0 ? [] : app.db.select().from(siteCrawlPages).where(and57(
-      eq67(siteCrawlPages.projectId, scope.projectId),
-      eq67(siteCrawlPages.runId, scope.runId),
-      eq67(siteCrawlPages.attemptId, scope.attemptId),
-      inArray26(siteCrawlPages.nodeKey, nodeKeys)
+    const pageRows = nodeKeys.length === 0 ? [] : app.db.select().from(siteCrawlPages).where(and59(
+      eq70(siteCrawlPages.projectId, scope.projectId),
+      eq70(siteCrawlPages.runId, scope.runId),
+      eq70(siteCrawlPages.attemptId, scope.attemptId),
+      inArray27(siteCrawlPages.nodeKey, nodeKeys)
     )).all();
     const persistedNodeKeys = new Set(pageRows.map((row) => row.nodeKey));
     const outermostNodeKeys = pageRows.filter((row) => distances.get(row.nodeKey) === hops).map((row) => row.nodeKey);
-    const omittedOutermostEdge = outermostNodeKeys.length === 0 ? void 0 : app.db.select({ edgeKey: siteCrawlEdges.edgeKey }).from(siteCrawlEdges).where(and57(
-      eq67(siteCrawlEdges.projectId, scope.projectId),
-      eq67(siteCrawlEdges.runId, scope.runId),
-      eq67(siteCrawlEdges.attemptId, scope.attemptId),
-      eq67(siteCrawlEdges.internal, true),
+    const omittedOutermostEdge = outermostNodeKeys.length === 0 ? void 0 : app.db.select({ edgeKey: siteCrawlEdges.edgeKey }).from(siteCrawlEdges).where(and59(
+      eq70(siteCrawlEdges.projectId, scope.projectId),
+      eq70(siteCrawlEdges.runId, scope.runId),
+      eq70(siteCrawlEdges.attemptId, scope.attemptId),
+      eq70(siteCrawlEdges.internal, true),
       isNotNull5(siteCrawlEdges.targetNodeKey),
-      inArray26(siteCrawlEdges.sourceNodeKey, outermostNodeKeys),
-      inArray26(siteCrawlEdges.targetNodeKey, outermostNodeKeys)
+      inArray27(siteCrawlEdges.sourceNodeKey, outermostNodeKeys),
+      inArray27(siteCrawlEdges.targetNodeKey, outermostNodeKeys)
     )).limit(1).get();
     if (omittedOutermostEdge && !seenEdgeKeys.has(omittedOutermostEdge.edgeKey)) {
       omittedEdgeKeys.add(omittedOutermostEdge.edgeKey);
@@ -84755,23 +85392,23 @@ async function technicalAeoRoutes(app, opts) {
     let found = fromPage.nodeKey === toPage.nodeKey;
     let truncated = false;
     for (let depth = 0; depth < maxDepth && frontier.length > 0 && !found; depth += 1) {
-      const candidates = app.db.select().from(siteCrawlEdges).where(and57(
-        eq67(siteCrawlEdges.projectId, scope.projectId),
-        eq67(siteCrawlEdges.runId, scope.runId),
-        eq67(siteCrawlEdges.attemptId, scope.attemptId),
-        eq67(siteCrawlEdges.internal, true),
-        eq67(siteCrawlEdges.followable, true),
-        eq67(siteCrawlEdges.relation, "anchor"),
+      const candidates = app.db.select().from(siteCrawlEdges).where(and59(
+        eq70(siteCrawlEdges.projectId, scope.projectId),
+        eq70(siteCrawlEdges.runId, scope.runId),
+        eq70(siteCrawlEdges.attemptId, scope.attemptId),
+        eq70(siteCrawlEdges.internal, true),
+        eq70(siteCrawlEdges.followable, true),
+        eq70(siteCrawlEdges.relation, "anchor"),
         isNotNull5(siteCrawlEdges.targetNodeKey),
-        inArray26(siteCrawlEdges.sourceNodeKey, frontier)
-      )).orderBy(asc11(siteCrawlEdges.edgeKey)).limit(SITE_HEALTH_PATH_MAX_VISITED_NODES + 1).all();
+        inArray27(siteCrawlEdges.sourceNodeKey, frontier)
+      )).orderBy(asc12(siteCrawlEdges.edgeKey)).limit(SITE_HEALTH_PATH_MAX_VISITED_NODES + 1).all();
       if (candidates.length > SITE_HEALTH_PATH_MAX_VISITED_NODES) truncated = true;
       const candidateTargetKeys = [...new Set(candidates.map((edge) => edge.targetNodeKey).filter((nodeKey) => nodeKey != null))];
-      const persistedTargetKeys = new Set(candidateTargetKeys.length === 0 ? [] : app.db.select({ nodeKey: siteCrawlPages.nodeKey }).from(siteCrawlPages).where(and57(
-        eq67(siteCrawlPages.projectId, scope.projectId),
-        eq67(siteCrawlPages.runId, scope.runId),
-        eq67(siteCrawlPages.attemptId, scope.attemptId),
-        inArray26(siteCrawlPages.nodeKey, candidateTargetKeys)
+      const persistedTargetKeys = new Set(candidateTargetKeys.length === 0 ? [] : app.db.select({ nodeKey: siteCrawlPages.nodeKey }).from(siteCrawlPages).where(and59(
+        eq70(siteCrawlPages.projectId, scope.projectId),
+        eq70(siteCrawlPages.runId, scope.runId),
+        eq70(siteCrawlPages.attemptId, scope.attemptId),
+        inArray27(siteCrawlPages.nodeKey, candidateTargetKeys)
       )).all().map((row) => row.nodeKey));
       const next = /* @__PURE__ */ new Set();
       for (const edge of candidates.slice(0, SITE_HEALTH_PATH_MAX_VISITED_NODES)) {
@@ -84813,11 +85450,11 @@ async function technicalAeoRoutes(app, opts) {
       pathEdges.unshift(step.edge);
       pathKeys.unshift(step.nodeKey);
     }
-    const pathRows = app.db.select().from(siteCrawlPages).where(and57(
-      eq67(siteCrawlPages.projectId, scope.projectId),
-      eq67(siteCrawlPages.runId, scope.runId),
-      eq67(siteCrawlPages.attemptId, scope.attemptId),
-      inArray26(siteCrawlPages.nodeKey, pathKeys)
+    const pathRows = app.db.select().from(siteCrawlPages).where(and59(
+      eq70(siteCrawlPages.projectId, scope.projectId),
+      eq70(siteCrawlPages.runId, scope.runId),
+      eq70(siteCrawlPages.attemptId, scope.attemptId),
+      inArray27(siteCrawlPages.nodeKey, pathKeys)
     )).all();
     const pageByKey = new Map(pathRows.map((row) => [row.nodeKey, row]));
     const pathDetection = templateDetectionOf(snapshot.templateDetection);
@@ -84846,21 +85483,21 @@ async function technicalAeoRoutes(app, opts) {
       throw validationError("change must be all, added, removed, or changed");
     }
     const completeSnapshotFilters = [
-      eq67(siteCrawlSnapshots.projectId, project.id),
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
-      eq67(runs.status, RunStatuses.completed),
-      eq67(siteCrawlSnapshots.complete, true),
+      eq70(siteCrawlSnapshots.projectId, project.id),
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
+      eq70(runs.status, RunStatuses.completed),
+      eq70(siteCrawlSnapshots.complete, true),
       notProbeRun()
     ];
-    const afterTarget = request.query.toRunId ? resolveCrawl(project.id, request.query.toRunId) : app.db.select({ snapshot: siteCrawlSnapshots, runStatus: runs.status }).from(siteCrawlSnapshots).innerJoin(runs, eq67(siteCrawlSnapshots.runId, runs.id)).where(and57(...completeSnapshotFilters)).orderBy(desc30(siteCrawlSnapshots.createdAt), desc30(siteCrawlSnapshots.runId)).limit(1).get();
+    const afterTarget = request.query.toRunId ? resolveCrawl(project.id, request.query.toRunId) : app.db.select({ snapshot: siteCrawlSnapshots, runStatus: runs.status }).from(siteCrawlSnapshots).innerJoin(runs, eq70(siteCrawlSnapshots.runId, runs.id)).where(and59(...completeSnapshotFilters)).orderBy(desc30(siteCrawlSnapshots.createdAt), desc30(siteCrawlSnapshots.runId)).limit(1).get();
     if (request.query.toRunId && !afterTarget) throw notFound("Site crawl run", request.query.toRunId);
-    const beforeTarget = request.query.fromRunId ? resolveCrawl(project.id, request.query.fromRunId) : afterTarget ? app.db.select({ snapshot: siteCrawlSnapshots, runStatus: runs.status }).from(siteCrawlSnapshots).innerJoin(runs, eq67(siteCrawlSnapshots.runId, runs.id)).where(and57(
+    const beforeTarget = request.query.fromRunId ? resolveCrawl(project.id, request.query.fromRunId) : afterTarget ? app.db.select({ snapshot: siteCrawlSnapshots, runStatus: runs.status }).from(siteCrawlSnapshots).innerJoin(runs, eq70(siteCrawlSnapshots.runId, runs.id)).where(and59(
       ...completeSnapshotFilters,
       or16(
         lt11(siteCrawlSnapshots.createdAt, afterTarget.snapshot.createdAt),
-        and57(
-          eq67(siteCrawlSnapshots.createdAt, afterTarget.snapshot.createdAt),
+        and59(
+          eq70(siteCrawlSnapshots.createdAt, afterTarget.snapshot.createdAt),
           lt11(siteCrawlSnapshots.runId, afterTarget.snapshot.runId)
         )
       )
@@ -85095,18 +85732,18 @@ async function technicalAeoRoutes(app, opts) {
     const visibleKeys = keyRows.slice(0, limit);
     const pageKeys = visibleKeys.filter((row) => row.entity === "page").map((row) => row.key);
     const linkKeys = visibleKeys.filter((row) => row.entity === "link").map((row) => row.key);
-    const pageRowsFor = (scope) => pageKeys.length === 0 ? [] : app.db.select().from(siteCrawlPages).where(and57(
-      eq67(siteCrawlPages.projectId, scope.projectId),
-      eq67(siteCrawlPages.runId, scope.runId),
-      eq67(siteCrawlPages.attemptId, scope.attemptId),
-      inArray26(siteCrawlPages.nodeKey, pageKeys)
+    const pageRowsFor = (scope) => pageKeys.length === 0 ? [] : app.db.select().from(siteCrawlPages).where(and59(
+      eq70(siteCrawlPages.projectId, scope.projectId),
+      eq70(siteCrawlPages.runId, scope.runId),
+      eq70(siteCrawlPages.attemptId, scope.attemptId),
+      inArray27(siteCrawlPages.nodeKey, pageKeys)
     )).all();
-    const edgeRowsFor = (scope) => linkKeys.length === 0 ? [] : app.db.select().from(siteCrawlEdges).where(and57(
-      eq67(siteCrawlEdges.projectId, scope.projectId),
-      eq67(siteCrawlEdges.runId, scope.runId),
-      eq67(siteCrawlEdges.attemptId, scope.attemptId),
-      eq67(siteCrawlEdges.internal, true),
-      inArray26(siteCrawlEdges.edgeKey, linkKeys)
+    const edgeRowsFor = (scope) => linkKeys.length === 0 ? [] : app.db.select().from(siteCrawlEdges).where(and59(
+      eq70(siteCrawlEdges.projectId, scope.projectId),
+      eq70(siteCrawlEdges.runId, scope.runId),
+      eq70(siteCrawlEdges.attemptId, scope.attemptId),
+      eq70(siteCrawlEdges.internal, true),
+      inArray27(siteCrawlEdges.edgeKey, linkKeys)
     )).all();
     const beforePages = new Map(pageRowsFor(beforeScope).map((row) => [row.nodeKey, mapCrawlPage(row)]));
     const afterPages = new Map(pageRowsFor(afterScope).map((row) => [row.nodeKey, mapCrawlPage(row)]));
@@ -85231,30 +85868,30 @@ async function technicalAeoRoutes(app, opts) {
       return { project: project.name, hasCrawlData: true, runId: snapshot.runId, total: 0, nextCursor: null, healthStateFilter: null, pages: [] };
     }
     const filters = [
-      eq67(siteCrawlPages.projectId, project.id),
-      eq67(siteCrawlPages.runId, snapshot.runId),
-      eq67(siteCrawlPages.attemptId, snapshot.attemptId)
+      eq70(siteCrawlPages.projectId, project.id),
+      eq70(siteCrawlPages.runId, snapshot.runId),
+      eq70(siteCrawlPages.attemptId, snapshot.attemptId)
     ];
-    if (request.query.nodeKey) filters.push(eq67(siteCrawlPages.nodeKey, request.query.nodeKey));
+    if (request.query.nodeKey) filters.push(eq70(siteCrawlPages.nodeKey, request.query.nodeKey));
     const inventoryEligible = parseBoolean2(request.query.inventoryEligible);
-    if (inventoryEligible != null) filters.push(eq67(siteCrawlPages.inventoryEligible, inventoryEligible));
-    if (request.query.fetchState) filters.push(eq67(siteCrawlPages.fetchState, request.query.fetchState));
-    if (request.query.indexabilityState) filters.push(eq67(siteCrawlPages.indexabilityState, request.query.indexabilityState));
-    if (request.query.auditState) filters.push(eq67(siteCrawlPages.auditState, request.query.auditState));
+    if (inventoryEligible != null) filters.push(eq70(siteCrawlPages.inventoryEligible, inventoryEligible));
+    if (request.query.fetchState) filters.push(eq70(siteCrawlPages.fetchState, request.query.fetchState));
+    if (request.query.indexabilityState) filters.push(eq70(siteCrawlPages.indexabilityState, request.query.indexabilityState));
+    if (request.query.auditState) filters.push(eq70(siteCrawlPages.auditState, request.query.auditState));
     const healthState = parseSiteHealthState(request.query.healthState);
     const limit = parseBoundedLimit(request.query.limit, 100, 200);
     const offset = decodeCursor(request.query.cursor);
-    const orderBy = request.query.sort === "score-desc" ? [desc30(siteCrawlPages.auditScore), asc11(siteCrawlPages.nodeKey)] : request.query.sort === "score-asc" ? [asc11(siteCrawlPages.auditScore), asc11(siteCrawlPages.nodeKey)] : request.query.sort === "path" ? [asc11(siteCrawlPages.path), asc11(siteCrawlPages.nodeKey)] : [asc11(siteCrawlPages.url), asc11(siteCrawlPages.nodeKey)];
+    const orderBy = request.query.sort === "score-desc" ? [desc30(siteCrawlPages.auditScore), asc12(siteCrawlPages.nodeKey)] : request.query.sort === "score-asc" ? [asc12(siteCrawlPages.auditScore), asc12(siteCrawlPages.nodeKey)] : request.query.sort === "path" ? [asc12(siteCrawlPages.path), asc12(siteCrawlPages.nodeKey)] : [asc12(siteCrawlPages.url), asc12(siteCrawlPages.nodeKey)];
     let healthStateFilter = null;
     if (healthState) {
-      const legacyRow = app.db.select({ id: siteCrawlPages.id }).from(siteCrawlPages).where(and57(
-        eq67(siteCrawlPages.projectId, project.id),
-        eq67(siteCrawlPages.runId, snapshot.runId),
-        eq67(siteCrawlPages.attemptId, snapshot.attemptId),
+      const legacyRow = app.db.select({ id: siteCrawlPages.id }).from(siteCrawlPages).where(and59(
+        eq70(siteCrawlPages.projectId, project.id),
+        eq70(siteCrawlPages.runId, snapshot.runId),
+        eq70(siteCrawlPages.attemptId, snapshot.attemptId),
         isNull12(siteCrawlPages.healthState)
       )).limit(1).get();
       healthStateFilter = legacyRow ? "unavailable-legacy-scan" : "applied";
-      if (healthStateFilter === "applied") filters.push(eq67(siteCrawlPages.healthState, healthState));
+      if (healthStateFilter === "applied") filters.push(eq70(siteCrawlPages.healthState, healthState));
     }
     if (healthStateFilter === "unavailable-legacy-scan") {
       return {
@@ -85267,7 +85904,7 @@ async function technicalAeoRoutes(app, opts) {
         pages: []
       };
     }
-    const where = and57(...filters);
+    const where = and59(...filters);
     const total = app.db.select({ value: count2() }).from(siteCrawlPages).where(where).get()?.value ?? 0;
     const rows = app.db.select().from(siteCrawlPages).where(where).orderBy(...orderBy).limit(limit).offset(offset).all();
     const nextOffset = offset + rows.length;
@@ -85298,10 +85935,10 @@ async function technicalAeoRoutes(app, opts) {
       url: siteCrawlPages.url,
       inventoryEligible: siteCrawlPages.inventoryEligible,
       fetchState: siteCrawlPages.fetchState
-    }).from(siteCrawlPages).where(and57(
-      eq67(siteCrawlPages.projectId, project.id),
-      eq67(siteCrawlPages.runId, snapshot.runId),
-      eq67(siteCrawlPages.attemptId, snapshot.attemptId)
+    }).from(siteCrawlPages).where(and59(
+      eq70(siteCrawlPages.projectId, project.id),
+      eq70(siteCrawlPages.runId, snapshot.runId),
+      eq70(siteCrawlPages.attemptId, snapshot.attemptId)
     )).limit(MAX_STRUCTURE_SOURCE_ROWS + 1).all();
     if (sourceRows.length > MAX_STRUCTURE_SOURCE_ROWS) {
       throw validationError(`Persisted crawl exceeds the ${MAX_STRUCTURE_SOURCE_ROWS}-page structure limit`);
@@ -85380,21 +86017,21 @@ async function technicalAeoRoutes(app, opts) {
       };
     }
     const filters = [
-      eq67(siteCrawlEdges.projectId, project.id),
-      eq67(siteCrawlEdges.runId, snapshot.runId),
-      eq67(siteCrawlEdges.attemptId, snapshot.attemptId),
-      eq67(siteCrawlEdges.internal, true),
+      eq70(siteCrawlEdges.projectId, project.id),
+      eq70(siteCrawlEdges.runId, snapshot.runId),
+      eq70(siteCrawlEdges.attemptId, snapshot.attemptId),
+      eq70(siteCrawlEdges.internal, true),
       linkKindFilter(linkKind)
     ];
-    if (request.query.sourceUrl) filters.push(eq67(siteCrawlEdges.sourceUrl, request.query.sourceUrl));
-    if (request.query.targetUrl) filters.push(eq67(siteCrawlEdges.targetUrl, request.query.targetUrl));
+    if (request.query.sourceUrl) filters.push(eq70(siteCrawlEdges.sourceUrl, request.query.sourceUrl));
+    if (request.query.targetUrl) filters.push(eq70(siteCrawlEdges.targetUrl, request.query.targetUrl));
     const followable = parseBoolean2(request.query.followable);
-    if (followable != null) filters.push(eq67(siteCrawlEdges.followable, followable));
-    const where = and57(...filters);
+    if (followable != null) filters.push(eq70(siteCrawlEdges.followable, followable));
+    const where = and59(...filters);
     const total = app.db.select({ value: count2() }).from(siteCrawlEdges).where(where).get()?.value ?? 0;
     const limit = parseBoundedLimit(request.query.limit, 100, 200);
     const offset = decodeCursor(request.query.cursor);
-    const rows = app.db.select().from(siteCrawlEdges).where(where).orderBy(asc11(siteCrawlEdges.edgeKey)).limit(limit).offset(offset).all();
+    const rows = app.db.select().from(siteCrawlEdges).where(where).orderBy(asc12(siteCrawlEdges.edgeKey)).limit(limit).offset(offset).all();
     const nextOffset = offset + rows.length;
     return {
       project: project.name,
@@ -85448,17 +86085,17 @@ async function technicalAeoRoutes(app, opts) {
       };
     }
     const scope = [
-      eq67(siteCrawlEdges.projectId, project.id),
-      eq67(siteCrawlEdges.runId, snapshot.runId),
-      eq67(siteCrawlEdges.attemptId, snapshot.attemptId),
-      eq67(siteCrawlEdges.internal, true),
+      eq70(siteCrawlEdges.projectId, project.id),
+      eq70(siteCrawlEdges.runId, snapshot.runId),
+      eq70(siteCrawlEdges.attemptId, snapshot.attemptId),
+      eq70(siteCrawlEdges.internal, true),
       linkKindFilter(linkKind)
     ];
-    const inboundMatch = request.query.nodeKey && request.query.url ? or16(eq67(siteCrawlEdges.targetNodeKey, request.query.nodeKey), eq67(siteCrawlEdges.targetUrl, request.query.url)) : request.query.nodeKey ? eq67(siteCrawlEdges.targetNodeKey, request.query.nodeKey) : eq67(siteCrawlEdges.targetUrl, request.query.url);
-    const outboundMatch = request.query.nodeKey && request.query.url ? or16(eq67(siteCrawlEdges.sourceNodeKey, request.query.nodeKey), eq67(siteCrawlEdges.sourceUrl, request.query.url)) : request.query.nodeKey ? eq67(siteCrawlEdges.sourceNodeKey, request.query.nodeKey) : eq67(siteCrawlEdges.sourceUrl, request.query.url);
+    const inboundMatch = request.query.nodeKey && request.query.url ? or16(eq70(siteCrawlEdges.targetNodeKey, request.query.nodeKey), eq70(siteCrawlEdges.targetUrl, request.query.url)) : request.query.nodeKey ? eq70(siteCrawlEdges.targetNodeKey, request.query.nodeKey) : eq70(siteCrawlEdges.targetUrl, request.query.url);
+    const outboundMatch = request.query.nodeKey && request.query.url ? or16(eq70(siteCrawlEdges.sourceNodeKey, request.query.nodeKey), eq70(siteCrawlEdges.sourceUrl, request.query.url)) : request.query.nodeKey ? eq70(siteCrawlEdges.sourceNodeKey, request.query.nodeKey) : eq70(siteCrawlEdges.sourceUrl, request.query.url);
     const limit = parseBoundedLimit(request.query.limit, 50, 100);
-    const inboundRows = app.db.select().from(siteCrawlEdges).where(and57(...scope, inboundMatch)).orderBy(asc11(siteCrawlEdges.edgeKey)).limit(limit + 1).all();
-    const outboundRows = app.db.select().from(siteCrawlEdges).where(and57(...scope, outboundMatch)).orderBy(asc11(siteCrawlEdges.edgeKey)).limit(limit + 1).all();
+    const inboundRows = app.db.select().from(siteCrawlEdges).where(and59(...scope, inboundMatch)).orderBy(asc12(siteCrawlEdges.edgeKey)).limit(limit + 1).all();
+    const outboundRows = app.db.select().from(siteCrawlEdges).where(and59(...scope, outboundMatch)).orderBy(asc12(siteCrawlEdges.edgeKey)).limit(limit + 1).all();
     return {
       project: project.name,
       hasCrawlData: true,
@@ -85491,11 +86128,11 @@ async function technicalAeoRoutes(app, opts) {
     if (!snapshot.attemptId) {
       return { project: project.name, runId: snapshot.runId, state: "partial", checkDeadLinks: true, checked: snapshot.deadLinksChecked, found: snapshot.deadLinksFound, unverified: snapshot.deadLinksUnverified, total: 0, nextCursor: null, deadLinks: [] };
     }
-    const where = and57(
-      eq67(siteCrawlFindings.projectId, project.id),
-      eq67(siteCrawlFindings.runId, snapshot.runId),
-      eq67(siteCrawlFindings.attemptId, snapshot.attemptId),
-      eq67(siteCrawlFindings.findingType, "dead-link"),
+    const where = and59(
+      eq70(siteCrawlFindings.projectId, project.id),
+      eq70(siteCrawlFindings.runId, snapshot.runId),
+      eq70(siteCrawlFindings.attemptId, snapshot.attemptId),
+      eq70(siteCrawlFindings.findingType, "dead-link"),
       // Belt and braces on the client-facing surface: a row without a status
       // code is not evidence of a broken link, and this response is where such
       // a row would be read as one. Migration 140 removed every stored row that
@@ -85510,7 +86147,7 @@ async function technicalAeoRoutes(app, opts) {
     const total = app.db.select({ value: count2() }).from(siteCrawlFindings).where(where).get()?.value ?? 0;
     const limit = parseBoundedLimit(request.query.limit, 100, 200);
     const offset = decodeCursor(request.query.cursor);
-    const rows = app.db.select().from(siteCrawlFindings).where(where).orderBy(asc11(siteCrawlFindings.findingKey)).limit(limit).offset(offset).all();
+    const rows = app.db.select().from(siteCrawlFindings).where(where).orderBy(asc12(siteCrawlFindings.findingKey)).limit(limit).offset(offset).all();
     const nextOffset = offset + rows.length;
     const deadLinks = rows.map((row) => ({
       findingKey: row.findingKey,
@@ -85544,19 +86181,19 @@ async function technicalAeoRoutes(app, opts) {
       createdAt: runs.createdAt,
       startedAt: runs.startedAt,
       finishedAt: runs.finishedAt
-    }).from(runs).where(and57(
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
+    }).from(runs).where(and59(
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
       notProbeRun()
     )).orderBy(desc30(runs.createdAt), desc30(runs.id)).limit(limit).all();
     const runIds = rows.map((row) => row.runId);
-    const crawlRunIds = new Set(runIds.length === 0 ? [] : app.db.select({ runId: siteCrawlSnapshots.runId }).from(siteCrawlSnapshots).innerJoin(runs, eq67(siteCrawlSnapshots.runId, runs.id)).where(and57(
-      eq67(siteCrawlSnapshots.projectId, project.id),
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
-      inArray26(runs.status, SURFACEABLE_STATUSES),
+    const crawlRunIds = new Set(runIds.length === 0 ? [] : app.db.select({ runId: siteCrawlSnapshots.runId }).from(siteCrawlSnapshots).innerJoin(runs, eq70(siteCrawlSnapshots.runId, runs.id)).where(and59(
+      eq70(siteCrawlSnapshots.projectId, project.id),
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
+      inArray27(runs.status, SURFACEABLE_STATUSES),
       notProbeRun(),
-      inArray26(siteCrawlSnapshots.runId, runIds)
+      inArray27(siteCrawlSnapshots.runId, runIds)
     )).all().map((row) => row.runId));
     return {
       project: project.name,
@@ -85569,21 +86206,21 @@ async function technicalAeoRoutes(app, opts) {
   });
   app.get("/projects/:name/technical-aeo/runs/:runId/progress", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const run = app.db.select().from(runs).where(and57(
-      eq67(runs.id, request.params.runId),
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
+    const run = app.db.select().from(runs).where(and59(
+      eq70(runs.id, request.params.runId),
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
       notProbeRun()
     )).get();
     if (!run) throw notFound("Site audit run", request.params.runId);
-    const attempt = app.db.select().from(siteCrawlAttempts).where(and57(
-      eq67(siteCrawlAttempts.projectId, project.id),
-      eq67(siteCrawlAttempts.runId, run.id)
+    const attempt = app.db.select().from(siteCrawlAttempts).where(and59(
+      eq70(siteCrawlAttempts.projectId, project.id),
+      eq70(siteCrawlAttempts.runId, run.id)
     )).orderBy(desc30(siteCrawlAttempts.attemptNumber), desc30(siteCrawlAttempts.updatedAt)).limit(1).get();
-    const persistedLayout = attempt ? app.db.select().from(siteCrawlGraphLayouts).where(and57(
-      eq67(siteCrawlGraphLayouts.projectId, project.id),
-      eq67(siteCrawlGraphLayouts.runId, run.id),
-      eq67(siteCrawlGraphLayouts.attemptId, attempt.id)
+    const persistedLayout = attempt ? app.db.select().from(siteCrawlGraphLayouts).where(and59(
+      eq70(siteCrawlGraphLayouts.projectId, project.id),
+      eq70(siteCrawlGraphLayouts.runId, run.id),
+      eq70(siteCrawlGraphLayouts.attemptId, attempt.id)
     )).get() : void 0;
     const layoutState = persistedLayout?.state === "ready" || persistedLayout?.state === "unavailable" ? persistedLayout.state : run.status === RunStatuses.completed || run.status === RunStatuses.partial ? "unavailable" : "pending";
     return {
@@ -85614,18 +86251,18 @@ async function technicalAeoRoutes(app, opts) {
     };
   });
   app.get("/projects/:name/technical-aeo/runs/:runId/page-health-preview", async (request) => app.db.transaction((tx) => {
-    const project = tx.select().from(projects).where(eq67(projects.name, request.params.name)).get();
+    const project = tx.select().from(projects).where(eq70(projects.name, request.params.name)).get();
     if (!project) throw notFound("Project", request.params.name);
-    const run = tx.select().from(runs).where(and57(
-      eq67(runs.id, request.params.runId),
-      eq67(runs.projectId, project.id),
-      eq67(runs.kind, RunKinds["site-audit"]),
+    const run = tx.select().from(runs).where(and59(
+      eq70(runs.id, request.params.runId),
+      eq70(runs.projectId, project.id),
+      eq70(runs.kind, RunKinds["site-audit"]),
       notProbeRun()
     )).get();
     if (!run) throw notFound("Site audit run", request.params.runId);
-    const attempt = tx.select().from(siteCrawlAttempts).where(and57(
-      eq67(siteCrawlAttempts.projectId, project.id),
-      eq67(siteCrawlAttempts.runId, run.id)
+    const attempt = tx.select().from(siteCrawlAttempts).where(and59(
+      eq70(siteCrawlAttempts.projectId, project.id),
+      eq70(siteCrawlAttempts.runId, run.id)
     )).orderBy(desc30(siteCrawlAttempts.attemptNumber), desc30(siteCrawlAttempts.updatedAt)).limit(1).get();
     const state = run.status === RunStatuses.queued ? "waiting" : run.status === RunStatuses.running ? "collecting" : "terminal";
     const base = {
@@ -85639,11 +86276,11 @@ async function technicalAeoRoutes(app, opts) {
     if (!attempt) {
       return { ...base, pagesAudited: 0, examples: [] };
     }
-    const auditedWhere = and57(
-      eq67(siteCrawlPages.projectId, project.id),
-      eq67(siteCrawlPages.runId, run.id),
-      eq67(siteCrawlPages.attemptId, attempt.id),
-      eq67(siteCrawlPages.auditState, "success")
+    const auditedWhere = and59(
+      eq70(siteCrawlPages.projectId, project.id),
+      eq70(siteCrawlPages.runId, run.id),
+      eq70(siteCrawlPages.attemptId, attempt.id),
+      eq70(siteCrawlPages.auditState, "success")
     );
     const pagesAudited = tx.select({ value: count2() }).from(siteCrawlPages).where(auditedWhere).get()?.value ?? 0;
     if (state !== "collecting") {
@@ -85654,11 +86291,11 @@ async function technicalAeoRoutes(app, opts) {
       url: siteCrawlPages.url,
       auditScore: siteCrawlPages.auditScore,
       auditFields: siteCrawlPages.auditFields
-    }).from(siteCrawlPages).where(and57(
+    }).from(siteCrawlPages).where(and59(
       auditedWhere,
       isNotNull5(siteCrawlPages.auditScore),
       lt11(siteCrawlPages.auditScore, 70)
-    )).orderBy(asc11(siteCrawlPages.auditScore), asc11(siteCrawlPages.nodeKey)).limit(LIVE_PAGE_HEALTH_CANDIDATE_LIMIT).all();
+    )).orderBy(asc12(siteCrawlPages.auditScore), asc12(siteCrawlPages.nodeKey)).limit(LIVE_PAGE_HEALTH_CANDIDATE_LIMIT).all();
     const examples = candidates.flatMap((candidate) => {
       if (candidate.auditScore == null) return [];
       const checksNeedingAttention = countLivePageHealthChecks(candidate.auditFields);
@@ -85690,13 +86327,13 @@ async function technicalAeoRoutes(app, opts) {
         status: runs.status,
         identityKey: siteCrawlRunRequests.identityKey,
         effectiveOptions: siteCrawlRunRequests.effectiveOptions
-      }).from(runs).leftJoin(siteCrawlRunRequests, and57(
-        eq67(siteCrawlRunRequests.projectId, runs.projectId),
-        eq67(siteCrawlRunRequests.runId, runs.id)
-      )).where(and57(
-        eq67(runs.projectId, project.id),
-        eq67(runs.kind, RunKinds["site-audit"]),
-        inArray26(runs.status, [RunStatuses.queued, RunStatuses.running])
+      }).from(runs).leftJoin(siteCrawlRunRequests, and59(
+        eq70(siteCrawlRunRequests.projectId, runs.projectId),
+        eq70(siteCrawlRunRequests.runId, runs.id)
+      )).where(and59(
+        eq70(runs.projectId, project.id),
+        eq70(runs.kind, RunKinds["site-audit"]),
+        inArray27(runs.status, [RunStatuses.queued, RunStatuses.running])
       )).get();
       if (existing) {
         if (existing.identityKey === identityKey) {
@@ -85750,7 +86387,7 @@ async function technicalAeoRoutes(app, opts) {
 // ../api-routes/src/research.ts
 import crypto50 from "crypto";
 import { z as z5 } from "zod";
-import { and as and58, count as count3, desc as desc31, eq as eq68, gte as gte17, lt as lt12, or as or17, sql as sql27 } from "drizzle-orm";
+import { and as and60, count as count3, desc as desc31, eq as eq71, gte as gte19, lt as lt12, or as or17, sql as sql27 } from "drizzle-orm";
 var sameLocation = (a, b) => a.label === b.label && a.city === b.city && a.region === b.region && a.country === b.country && a.timezone === b.timezone;
 var BATCH_RECEIPT_PREFIX = "__canonry_research_batch__:";
 async function researchRoutes(app, opts) {
@@ -85768,7 +86405,7 @@ async function researchRoutes(app, opts) {
     const input = parsed.data;
     if (input.idempotencyKey?.startsWith(BATCH_RECEIPT_PREFIX)) throw validationError("This idempotency key prefix is reserved for internal research batch receipts.");
     const requestHash2 = directResearchRequestHash(input);
-    const existingReceipt = input.idempotencyKey ? app.db.select().from(researchRuns).where(and58(eq68(researchRuns.projectId, project.id), eq68(researchRuns.idempotencyKey, input.idempotencyKey))).get() : void 0;
+    const existingReceipt = input.idempotencyKey ? app.db.select().from(researchRuns).where(and60(eq71(researchRuns.projectId, project.id), eq71(researchRuns.idempotencyKey, input.idempotencyKey))).get() : void 0;
     if (existingReceipt) {
       assertSameDirectResearchRequest(existingReceipt, input, requestHash2);
       const result2 = getDetail(app, project.id, existingReceipt.id);
@@ -85800,7 +86437,7 @@ async function researchRoutes(app, opts) {
     const initiatedBy = researchPrincipal(request);
     const decision = app.db.transaction((tx) => {
       if (input.idempotencyKey) {
-        const existing = tx.select().from(researchRuns).where(and58(eq68(researchRuns.projectId, project.id), eq68(researchRuns.idempotencyKey, input.idempotencyKey))).get();
+        const existing = tx.select().from(researchRuns).where(and60(eq71(researchRuns.projectId, project.id), eq71(researchRuns.idempotencyKey, input.idempotencyKey))).get();
         if (existing) {
           assertSameDirectResearchRequest(existing, input, requestHash2);
           return { reused: true, id: existing.id, shouldDispatch: existing.status === ResearchRunStatuses.queued };
@@ -85808,9 +86445,9 @@ async function researchRoutes(app, opts) {
       }
       if (initiatedBy?.limited) {
         const { start, end, date } = utcDayBounds(now);
-        const used = tx.select({ value: count3() }).from(researchRuns).where(and58(
-          eq68(researchRuns.projectId, project.id),
-          gte17(researchRuns.createdAt, start),
+        const used = tx.select({ value: count3() }).from(researchRuns).where(and60(
+          eq71(researchRuns.projectId, project.id),
+          gte19(researchRuns.createdAt, start),
           lt12(researchRuns.createdAt, end),
           sql27`(json_extract(${researchRuns.initiatedBy}, '$.role') = ${UserRoles.viewer} OR json_extract(${researchRuns.initiatedBy}, '$.limited') = 1)`
         )).get()?.value ?? 0;
@@ -85840,15 +86477,15 @@ async function researchRoutes(app, opts) {
     if (input.idempotencyKey.startsWith(BATCH_RECEIPT_PREFIX)) throw validationError("This idempotency key prefix is reserved for internal research batch receipts.");
     const requestHash2 = researchBatchRequestHash(input);
     const receiptKeys = input.runs.map((_run, index2) => batchChildReceiptKey(input.idempotencyKey, index2));
-    const firstReceipt = app.db.select().from(researchRuns).where(and58(
-      eq68(researchRuns.projectId, project.id),
-      eq68(researchRuns.idempotencyKey, receiptKeys[0])
+    const firstReceipt = app.db.select().from(researchRuns).where(and60(
+      eq71(researchRuns.projectId, project.id),
+      eq71(researchRuns.idempotencyKey, receiptKeys[0])
     )).get();
     if (firstReceipt) {
       if (firstReceipt.requestHash !== requestHash2) throw alreadyExists("Research batch idempotency key", input.idempotencyKey);
-      const saved = receiptKeys.map((key) => app.db.select().from(researchRuns).where(and58(
-        eq68(researchRuns.projectId, project.id),
-        eq68(researchRuns.idempotencyKey, key)
+      const saved = receiptKeys.map((key) => app.db.select().from(researchRuns).where(and60(
+        eq71(researchRuns.projectId, project.id),
+        eq71(researchRuns.idempotencyKey, key)
       )).get());
       if (saved.some((row) => !row || row.requestHash !== requestHash2)) throw alreadyExists("Research batch idempotency key", input.idempotencyKey);
       const runs3 = saved.map((row) => getDetail(app, project.id, row.id));
@@ -85863,9 +86500,9 @@ async function researchRoutes(app, opts) {
     const decision = app.db.transaction((tx) => {
       if (initiatedBy?.limited) {
         const { start, end, date } = utcDayBounds(now);
-        const used = tx.select({ value: count3() }).from(researchRuns).where(and58(
-          eq68(researchRuns.projectId, project.id),
-          gte17(researchRuns.createdAt, start),
+        const used = tx.select({ value: count3() }).from(researchRuns).where(and60(
+          eq71(researchRuns.projectId, project.id),
+          gte19(researchRuns.createdAt, start),
           lt12(researchRuns.createdAt, end),
           sql27`(json_extract(${researchRuns.initiatedBy}, '$.role') = ${UserRoles.viewer} OR json_extract(${researchRuns.initiatedBy}, '$.limited') = 1)`
         )).get()?.value ?? 0;
@@ -85918,9 +86555,9 @@ async function researchRoutes(app, opts) {
     const requested = Number.parseInt(request.query.limit ?? "", 10);
     const limit = Number.isInteger(requested) && requested > 0 ? Math.min(requested, 100) : 20;
     const cursor = request.query.cursor ? parseResearchCursor(request.query.cursor, project.id) : null;
-    const rows = app.db.select().from(researchRuns).where(and58(
-      eq68(researchRuns.projectId, project.id),
-      cursor ? or17(lt12(researchRuns.createdAt, cursor.createdAt), and58(eq68(researchRuns.createdAt, cursor.createdAt), lt12(researchRuns.id, cursor.id))) : void 0
+    const rows = app.db.select().from(researchRuns).where(and60(
+      eq71(researchRuns.projectId, project.id),
+      cursor ? or17(lt12(researchRuns.createdAt, cursor.createdAt), and60(eq71(researchRuns.createdAt, cursor.createdAt), lt12(researchRuns.id, cursor.id))) : void 0
     )).orderBy(desc31(researchRuns.createdAt), desc31(researchRuns.id)).limit(limit + 1).all();
     const runs2 = rows.slice(0, limit).map(serializeRun);
     const last = runs2.at(-1);
@@ -86047,9 +86684,9 @@ function resolveStoredResearchTemplate(stored, selection, idempotencyKey) {
   return stored;
 }
 function resolveResearchTemplate(app, projectId, selection, scope, location) {
-  const savedTemplate = app.db.select().from(measurementQueryTemplates).where(and58(
-    eq68(measurementQueryTemplates.projectId, projectId),
-    eq68(measurementQueryTemplates.id, selection.templateId)
+  const savedTemplate = app.db.select().from(measurementQueryTemplates).where(and60(
+    eq71(measurementQueryTemplates.projectId, projectId),
+    eq71(measurementQueryTemplates.id, selection.templateId)
   )).get();
   if (!savedTemplate) throw validationError("Unknown or stale research template. Reload the selected template and try again.");
   const templateVersion = savedTemplate.updatedAt;
@@ -86058,7 +86695,7 @@ function resolveResearchTemplate(app, projectId, selection, scope, location) {
   }
   const bindingLocation = selection.bindingLocation === void 0 ? location : selection.bindingLocation;
   if (bindingLocation) {
-    const project = app.db.select({ locations: projects.locations }).from(projects).where(eq68(projects.id, projectId)).get();
+    const project = app.db.select({ locations: projects.locations }).from(projects).where(eq71(projects.id, projectId)).get();
     if (!project.locations.some((item2) => sameLocation(item2, bindingLocation))) throw validationError("Research template binding location must match a configured project location.");
   }
   const { bindings, output } = expandResearchTemplate(savedTemplate, scope, bindingLocation);
@@ -86071,9 +86708,9 @@ function classifyResearchQueries(project, plan, queries2) {
   return queries2.map((query) => classifier?.classify(query) ?? null);
 }
 function getDetail(app, projectId, id) {
-  const row = app.db.select().from(researchRuns).where(and58(eq68(researchRuns.id, id), eq68(researchRuns.projectId, projectId))).get();
+  const row = app.db.select().from(researchRuns).where(and60(eq71(researchRuns.id, id), eq71(researchRuns.projectId, projectId))).get();
   if (!row) throw notFound("Research run", id);
-  const queries2 = app.db.select().from(researchRunQueries).where(eq68(researchRunQueries.researchRunId, id)).orderBy(researchRunQueries.position).all().map(serializeQuery);
+  const queries2 = app.db.select().from(researchRunQueries).where(eq71(researchRunQueries.researchRunId, id)).orderBy(researchRunQueries.position).all().map(serializeQuery);
   return { ...serializeRun(row), queries: queries2 };
 }
 function serializeRun(row) {
@@ -86102,7 +86739,7 @@ function utcDayBounds(now) {
 }
 
 // ../api-routes/src/plan-competitors.ts
-import { eq as eq69 } from "drizzle-orm";
+import { eq as eq72 } from "drizzle-orm";
 function competitorKey(value) {
   const host = (hostOf(value) ?? value).trim().toLowerCase().replace(/\.$/, "");
   return host.startsWith("www.") ? host.slice(4) : host;
@@ -86118,7 +86755,7 @@ function toList(merged) {
   return [...merged].sort(([left], [right]) => left.localeCompare(right)).map(([domain, names]) => ({ domain, aliases: [...names] }));
 }
 function readScope(db, versionId) {
-  const row = db.select({ canonicalJson: measurementPlanVersions.canonicalJson }).from(measurementPlanVersions).where(eq69(measurementPlanVersions.id, versionId)).get();
+  const row = db.select({ canonicalJson: measurementPlanVersions.canonicalJson }).from(measurementPlanVersions).where(eq72(measurementPlanVersions.id, versionId)).get();
   if (!row) return null;
   let groups;
   let edges;
@@ -86182,7 +86819,7 @@ function createRunCompetitorResolver(db, projectCompetitorDomains) {
 
 // ../api-routes/src/simple-measurement-definitions.ts
 import crypto51 from "crypto";
-import { and as and59, eq as eq70 } from "drizzle-orm";
+import { and as and61, eq as eq73 } from "drizzle-orm";
 function captureSimpleMeasurementDefinition(db, input) {
   return db.transaction((tx) => {
     const run = tx.select({
@@ -86190,7 +86827,7 @@ function captureSimpleMeasurementDefinition(db, input) {
       trigger: runs.trigger,
       status: runs.status,
       measurementPlanVersionId: runs.measurementPlanVersionId
-    }).from(runs).where(and59(eq70(runs.projectId, input.projectId), eq70(runs.id, input.runId))).get();
+    }).from(runs).where(and61(eq73(runs.projectId, input.projectId), eq73(runs.id, input.runId))).get();
     if (!run) throw notFound("Run", input.runId);
     if (run.kind !== RunKinds["answer-visibility"] || run.trigger === RunTriggers.probe || run.measurementPlanVersionId !== null) {
       return null;
@@ -86200,7 +86837,7 @@ function captureSimpleMeasurementDefinition(db, input) {
     if (definition.queries.some((query) => query.queryClass !== (classifier?.classify(query.queryText) ?? null))) {
       throw validationError("Query classes must match the captured identity and text.");
     }
-    const existing = tx.select().from(simpleMeasurementDefinitions).where(and59(eq70(simpleMeasurementDefinitions.projectId, input.projectId), eq70(simpleMeasurementDefinitions.runId, input.runId))).get();
+    const existing = tx.select().from(simpleMeasurementDefinitions).where(and61(eq73(simpleMeasurementDefinitions.projectId, input.projectId), eq73(simpleMeasurementDefinitions.runId, input.runId))).get();
     if (existing) {
       const frozen = simpleMeasurementDefinitionSchema.parse(existing.definition);
       const replayDefinition = {
@@ -86221,15 +86858,15 @@ function captureSimpleMeasurementDefinition(db, input) {
     if (run.status !== RunStatuses.running) {
       throw validationError("Only a running run can capture a new measurement definition.");
     }
-    if (tx.select({ id: querySnapshots.id }).from(querySnapshots).where(eq70(querySnapshots.runId, input.runId)).limit(1).get()) {
+    if (tx.select({ id: querySnapshots.id }).from(querySnapshots).where(eq73(querySnapshots.runId, input.runId)).limit(1).get()) {
       throw validationError("This run already has stored answers. Its measurement definition cannot be inferred afterward.");
     }
-    const projectQueryIds = new Set(tx.select({ id: queries.id }).from(queries).where(eq70(queries.projectId, input.projectId)).all().map((query) => query.id));
+    const projectQueryIds = new Set(tx.select({ id: queries.id }).from(queries).where(eq73(queries.projectId, input.projectId)).all().map((query) => query.id));
     if (definition.queries.some((query) => !projectQueryIds.has(query.queryId))) {
       throw validationError("Every captured query must belong to the run project.");
     }
     if (definition.competitors !== void 0) {
-      const liveCompetitorDomains = new Set(tx.select({ domain: competitors.domain }).from(competitors).where(eq70(competitors.projectId, input.projectId)).all().map((competitor) => competitor.domain));
+      const liveCompetitorDomains = new Set(tx.select({ domain: competitors.domain }).from(competitors).where(eq73(competitors.projectId, input.projectId)).all().map((competitor) => competitor.domain));
       const capturedDomains = new Set(definition.competitors.map((competitor) => competitor.domain));
       if (liveCompetitorDomains.size !== capturedDomains.size || [...liveCompetitorDomains].some((domain) => !capturedDomains.has(domain))) {
         throw validationError("Captured competitors must exactly match the project competitors dispatched for this run.");
@@ -87180,10 +87817,10 @@ var log = createLogger("IntelligenceService");
 var runChronologyKey = sql28`coalesce(${runs.finishedAt}, ${runs.createdAt})`;
 function analyzableRunPredicates(projectId) {
   return [
-    eq71(runs.projectId, projectId),
+    eq74(runs.projectId, projectId),
     // Only this kind writes query_snapshots.
-    eq71(runs.kind, RunKinds["answer-visibility"]),
-    or18(eq71(runs.status, RunStatuses.completed), eq71(runs.status, RunStatuses.partial)),
+    eq74(runs.kind, RunKinds["answer-visibility"]),
+    or18(eq74(runs.status, RunStatuses.completed), eq74(runs.status, RunStatuses.partial)),
     // Defensive: RunCoordinator already skips probes before analyzeAndPersist
     // is called, but a future call site invoking it directly for a probe must
     // still not pollute the intelligence window.
@@ -87228,24 +87865,24 @@ var IntelligenceService = class {
    * Returns the analysis result for the coordinator to inspect (e.g. for webhook dispatch).
    */
   analyzeAndPersist(runId, projectId) {
-    const currentRunRecord = this.db.select().from(runs).where(and60(eq71(runs.id, runId), ...analyzableRunPredicates(projectId))).get();
+    const currentRunRecord = this.db.select().from(runs).where(and62(eq74(runs.id, runId), ...analyzableRunPredicates(projectId))).get();
     if (!currentRunRecord) {
       log.info("intelligence.skip", { runId, reason: "run not eligible for analysis" });
       return null;
     }
     const currentLocation = currentRunRecord.location ?? null;
     const recentRuns = this.db.select().from(runs).where(
-      and60(
+      and62(
         ...analyzableRunPredicates(projectId),
-        currentLocation === null ? isNull13(runs.location) : eq71(runs.location, currentLocation),
+        currentLocation === null ? isNull13(runs.location) : eq74(runs.location, currentLocation),
         // Never look forward. The window is this run's own past, so
         // re-analyzing a historical run compares it against its true
         // predecessor rather than against sweeps that came after it.
-        lte15(runChronologyKey, currentRunRecord.finishedAt ?? currentRunRecord.createdAt),
+        lte17(runChronologyKey, currentRunRecord.finishedAt ?? currentRunRecord.createdAt),
         // MEASUREMENT: only runs that actually wrote snapshots — see above.
         // Index seek on idx_snapshots_run, short-circuited on the first row.
         exists(
-          this.db.select({ one: sql28`1` }).from(querySnapshots).where(eq71(querySnapshots.runId, runs.id))
+          this.db.select({ one: sql28`1` }).from(querySnapshots).where(eq74(querySnapshots.runId, runs.id))
         )
       )
     ).orderBy(desc32(runs.finishedAt), desc32(runs.createdAt)).limit(HISTORY_WINDOW_RUNS).all();
@@ -87320,7 +87957,7 @@ var IntelligenceService = class {
    * Returns the persisted insights so the coordinator can count critical/high.
    */
   analyzeAndPersistGbp(runId, projectId) {
-    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq71(runs.id, runId)).get();
+    const runRow = this.db.select({ createdAt: runs.createdAt, startedAt: runs.startedAt, finishedAt: runs.finishedAt }).from(runs).where(eq74(runs.id, runId)).get();
     if (!runRow) {
       log.info("gbp-intelligence.skip", { runId, reason: "run not found" });
       this.persistGbpInsights(runId, projectId, [], []);
@@ -87328,11 +87965,11 @@ var IntelligenceService = class {
     }
     const windowStart = runRow.startedAt ?? runRow.createdAt;
     const windowEnd = runRow.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-    const selected = this.db.select().from(gbpLocations).where(and60(
-      eq71(gbpLocations.projectId, projectId),
-      eq71(gbpLocations.selected, true),
-      gte18(gbpLocations.syncedAt, windowStart),
-      lte15(gbpLocations.syncedAt, windowEnd)
+    const selected = this.db.select().from(gbpLocations).where(and62(
+      eq74(gbpLocations.projectId, projectId),
+      eq74(gbpLocations.selected, true),
+      gte20(gbpLocations.syncedAt, windowStart),
+      lte17(gbpLocations.syncedAt, windowEnd)
     )).all();
     if (selected.length === 0) {
       log.info("gbp-intelligence.skip", { runId, reason: "no locations synced during run" });
@@ -87365,12 +88002,12 @@ var IntelligenceService = class {
   }
   /** Build the per-location signal bundle the GBP analyzer consumes. */
   buildGbpLocationSignals(projectId, locationName, displayName, fallbackDate) {
-    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and60(eq71(gbpDailyMetrics.projectId, projectId), eq71(gbpDailyMetrics.locationName, locationName))).all();
-    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and60(eq71(gbpPlaceActions.projectId, projectId), eq71(gbpPlaceActions.locationName, locationName))).all();
-    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and60(eq71(gbpLodgingSnapshots.projectId, projectId), eq71(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc32(gbpLodgingSnapshots.syncedAt)).limit(1).get();
-    const ownerRow = this.db.select({ description: gbpLocations.description }).from(gbpLocations).where(and60(eq71(gbpLocations.projectId, projectId), eq71(gbpLocations.locationName, locationName))).get();
+    const metricRows = this.db.select({ metric: gbpDailyMetrics.metric, date: gbpDailyMetrics.date, value: gbpDailyMetrics.value }).from(gbpDailyMetrics).where(and62(eq74(gbpDailyMetrics.projectId, projectId), eq74(gbpDailyMetrics.locationName, locationName))).all();
+    const placeActionRows = this.db.select({ placeActionType: gbpPlaceActions.placeActionType, providerType: gbpPlaceActions.providerType }).from(gbpPlaceActions).where(and62(eq74(gbpPlaceActions.projectId, projectId), eq74(gbpPlaceActions.locationName, locationName))).all();
+    const lodgingRow = this.db.select({ populatedGroupCount: gbpLodgingSnapshots.populatedGroupCount }).from(gbpLodgingSnapshots).where(and62(eq74(gbpLodgingSnapshots.projectId, projectId), eq74(gbpLodgingSnapshots.locationName, locationName))).orderBy(desc32(gbpLodgingSnapshots.syncedAt)).limit(1).get();
+    const ownerRow = this.db.select({ description: gbpLocations.description }).from(gbpLocations).where(and62(eq74(gbpLocations.projectId, projectId), eq74(gbpLocations.locationName, locationName))).get();
     const descriptionMissing = !(ownerRow?.description ?? "").trim();
-    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and60(eq71(gbpPlaceDetails.projectId, projectId), eq71(gbpPlaceDetails.locationName, locationName))).orderBy(desc32(gbpPlaceDetails.syncedAt)).limit(1).get();
+    const placeRow = this.db.select({ attributes: gbpPlaceDetails.attributes }).from(gbpPlaceDetails).where(and62(eq74(gbpPlaceDetails.projectId, projectId), eq74(gbpPlaceDetails.locationName, locationName))).orderBy(desc32(gbpPlaceDetails.syncedAt)).limit(1).get();
     const placesAmenities = placeRow ? extractPlaceAmenities(placeRow.attributes) : [];
     const summary3 = buildGbpSummary({
       locationName,
@@ -87406,7 +88043,7 @@ var IntelligenceService = class {
   /** Build the month-over-month keyword series for a location from the
    *  accumulating gbp_keyword_monthly table (latest complete month vs prior). */
   buildGbpKeywordTrend(projectId, locationName) {
-    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and60(eq71(gbpKeywordMonthly.projectId, projectId), eq71(gbpKeywordMonthly.locationName, locationName))).all();
+    const rows = this.db.select({ month: gbpKeywordMonthly.month, keyword: gbpKeywordMonthly.keyword, valueCount: gbpKeywordMonthly.valueCount }).from(gbpKeywordMonthly).where(and62(eq74(gbpKeywordMonthly.projectId, projectId), eq74(gbpKeywordMonthly.locationName, locationName))).all();
     if (rows.length === 0) return { recentMonth: null, priorMonth: null, points: [] };
     const months = [...new Set(rows.map((r) => r.month))].sort().reverse();
     const recentMonth = months[0] ?? null;
@@ -87437,7 +88074,7 @@ var IntelligenceService = class {
    */
   persistGbpInsights(runId, projectId, gbpInsights, coveredLocationNames) {
     const covered = new Set(coveredLocationNames);
-    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and60(eq71(insights.projectId, projectId), eq71(insights.provider, GBP_INSIGHT_PROVIDER))).all();
+    const existing = this.db.select({ id: insights.id, dismissed: insights.dismissed }).from(insights).where(and62(eq74(insights.projectId, projectId), eq74(insights.provider, GBP_INSIGHT_PROVIDER))).all();
     const staleIds = [];
     const dismissedSlots = /* @__PURE__ */ new Set();
     for (const row of existing) {
@@ -87448,7 +88085,7 @@ var IntelligenceService = class {
     }
     this.db.transaction((tx) => {
       for (const id of staleIds) {
-        tx.delete(insights).where(eq71(insights.id, id)).run();
+        tx.delete(insights).where(eq74(insights.id, id)).run();
       }
       for (const insight of gbpInsights) {
         const parsed = parseGbpInsightId(insight.id);
@@ -87534,7 +88171,7 @@ var IntelligenceService = class {
    *     create per run + aggregate). DB is left untouched.
    */
   backfill(projectName, opts, onProgress) {
-    const project = this.db.select().from(projects).where(eq71(projects.name, projectName)).get();
+    const project = this.db.select().from(projects).where(eq74(projects.name, projectName)).get();
     if (!project) {
       throw new Error(`Project "${projectName}" not found`);
     }
@@ -87546,7 +88183,7 @@ var IntelligenceService = class {
       }
       sinceTimestamp = parsed;
     }
-    const allRuns = this.db.select().from(runs).where(and60(...analyzableRunPredicates(project.id))).orderBy(asc12(runs.finishedAt)).all();
+    const allRuns = this.db.select().from(runs).where(and62(...analyzableRunPredicates(project.id))).orderBy(asc13(runs.finishedAt)).all();
     const measuredRunIds = this.runIdsWithSnapshots(allRuns.map((r) => r.id));
     const measuredRuns = allRuns.filter((r) => measuredRunIds.has(r.id));
     let startIdx = 0;
@@ -87577,7 +88214,7 @@ var IntelligenceService = class {
     let wouldDeleteTotal = 0;
     const existingByRunId = /* @__PURE__ */ new Map();
     if (isDryRun && targetRuns.length > 0) {
-      const rows = this.db.select({ runId: insights.runId }).from(insights).where(inArray27(insights.runId, targetRuns.map((r) => r.id))).all();
+      const rows = this.db.select({ runId: insights.runId }).from(insights).where(inArray28(insights.runId, targetRuns.map((r) => r.id))).all();
       for (const r of rows) {
         if (r.runId == null) continue;
         existingByRunId.set(r.runId, (existingByRunId.get(r.runId) ?? 0) + 1);
@@ -87623,7 +88260,7 @@ var IntelligenceService = class {
     return { processed, skipped: skipped3, totalInsights };
   }
   loadTrackedCompetitors(projectId) {
-    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq71(competitors.projectId, projectId)).all().map((r) => r.domain);
+    return this.db.select({ domain: competitors.domain }).from(competitors).where(eq74(competitors.projectId, projectId)).all().map((r) => r.domain);
   }
   /**
    * Which of `runIds` actually wrote query snapshots. One grouped read, so
@@ -87632,7 +88269,7 @@ var IntelligenceService = class {
    */
   runIdsWithSnapshots(runIds) {
     if (runIds.length === 0) return /* @__PURE__ */ new Set();
-    const rows = this.db.select({ runId: querySnapshots.runId }).from(querySnapshots).where(inArray27(querySnapshots.runId, [...runIds])).groupBy(querySnapshots.runId).all();
+    const rows = this.db.select({ runId: querySnapshots.runId }).from(querySnapshots).where(inArray28(querySnapshots.runId, [...runIds])).groupBy(querySnapshots.runId).all();
     return new Set(rows.map((r) => r.runId));
   }
   /**
@@ -87654,15 +88291,15 @@ var IntelligenceService = class {
   }
   persistResult(result, runId, projectId) {
     const previouslyDismissed = /* @__PURE__ */ new Set();
-    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq71(insights.runId, runId)).all();
+    const existingInsights = this.db.select({ query: insights.query, provider: insights.provider, type: insights.type, dismissed: insights.dismissed }).from(insights).where(eq74(insights.runId, runId)).all();
     for (const row of existingInsights) {
       if (row.dismissed) {
         previouslyDismissed.add(`${row.query}:${row.provider}:${row.type}`);
       }
     }
     this.db.transaction((tx) => {
-      tx.delete(insights).where(eq71(insights.runId, runId)).run();
-      tx.delete(healthSnapshots).where(eq71(healthSnapshots.runId, runId)).run();
+      tx.delete(insights).where(eq74(insights.runId, runId)).run();
+      tx.delete(healthSnapshots).where(eq74(healthSnapshots.runId, runId)).run();
       const now = (/* @__PURE__ */ new Date()).toISOString();
       for (const insight of result.insights) {
         const wasDismissed = previouslyDismissed.has(`${insight.query}:${insight.provider}:${insight.type}`);
@@ -87709,10 +88346,10 @@ var IntelligenceService = class {
       clicks: gscSearchData.clicks,
       impressions: gscSearchData.impressions,
       position: gscSearchData.position
-    }).from(gscSearchData).where(and60(
-      eq71(gscSearchData.projectId, projectId),
-      gte18(gscSearchData.date, window.startDate),
-      lte15(gscSearchData.date, window.endDate)
+    }).from(gscSearchData).where(and62(
+      eq74(gscSearchData.projectId, projectId),
+      gte20(gscSearchData.date, window.startDate),
+      lte17(gscSearchData.date, window.endDate)
     )).all();
     const byDay = /* @__PURE__ */ new Map();
     for (const r of rows) {
@@ -87763,17 +88400,17 @@ var IntelligenceService = class {
       const key = row.query.toLowerCase();
       gscImpressionsByQuery.set(key, (gscImpressionsByQuery.get(key) ?? 0) + row.impressions);
     }
-    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq71(projects.id, projectId)).get();
+    const projectRow = this.db.select({ locations: projects.locations }).from(projects).where(eq74(projects.id, projectId)).get();
     const locationCount = Math.max(
       1,
       (projectRow?.locations ?? []).length
     );
     const ROWS_PER_GROUP_BUDGET = Math.max(2, locationCount);
     const recentRunRows = this.db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(
-      and60(
-        eq71(runs.projectId, projectId),
-        eq71(runs.kind, RunKinds["answer-visibility"]),
-        or18(eq71(runs.status, "completed"), eq71(runs.status, "partial")),
+      and62(
+        eq74(runs.projectId, projectId),
+        eq74(runs.kind, RunKinds["answer-visibility"]),
+        or18(eq74(runs.status, "completed"), eq74(runs.status, "partial")),
         // Defensive — see top of file.
         ne11(runs.trigger, RunTriggers.probe)
       )
@@ -87793,7 +88430,7 @@ var IntelligenceService = class {
     const haveHistory = recentRunIds.length > 0;
     const priorRegressionsByPair = /* @__PURE__ */ new Map();
     if (haveHistory) {
-      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and60(eq71(insights.type, "regression"), inArray27(insights.runId, recentRunIds))).all();
+      const priorRows = this.db.select({ query: insights.query, provider: insights.provider, runId: insights.runId }).from(insights).where(and62(eq74(insights.type, "regression"), inArray28(insights.runId, recentRunIds))).all();
       const regressionGroups = /* @__PURE__ */ new Map();
       for (const row of priorRows) {
         if (!row.runId) continue;
@@ -87822,7 +88459,7 @@ var IntelligenceService = class {
     });
   }
   buildRunData(runId, projectId, completedAt, location = null, trackedCompetitors = []) {
-    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq71(projects.id, projectId)).get();
+    const projectDomainRow = this.db.select({ canonicalDomain: projects.canonicalDomain, ownedDomains: projects.ownedDomains }).from(projects).where(eq74(projects.id, projectId)).get();
     const projectDomains = projectDomainRow ? effectiveDomains({
       canonicalDomain: projectDomainRow.canonicalDomain,
       ownedDomains: projectDomainRow.ownedDomains
@@ -87840,7 +88477,7 @@ var IntelligenceService = class {
       citedDomains: querySnapshots.citedDomains,
       rawResponse: querySnapshots.rawResponse,
       snapshotLocation: querySnapshots.location
-    }).from(querySnapshots).leftJoin(queries, eq71(querySnapshots.queryId, queries.id)).where(eq71(querySnapshots.runId, runId)).all();
+    }).from(querySnapshots).leftJoin(queries, eq74(querySnapshots.queryId, queries.id)).where(eq74(querySnapshots.runId, runId)).all();
     const snapshots = [];
     let orphanCount = 0;
     for (const r of rows) {
@@ -88062,6 +88699,7 @@ export {
   generateWranglerToml,
   SITE_REACHABILITY_CHECK_ID,
   SITE_REACHABILITY_CHECKS,
+  scheduledHealthCheckIds,
   runChecks,
   executeDiscovery,
   markSessionFailed,