@canonry/canonry 5.17.0 → 5.19.0

package/dist/{demo-server-CUBR2NVR.js → demo-server-BOIBS74F.js}

@@ -4,10 +4,11 @@ import {
 import {
   layoutSiteCrawlGraphInput,
   persistSiteCrawlGraphLayout
-} from "./chunk-3OYWLQEE.js";
+} from "./chunk-QJWIOCEO.js";
 import {
-  PACKAGE_VERSION
-} from "./chunk-AOJU5LKX.js";
+  PACKAGE_VERSION,
+  canonryMcpTools
+} from "./chunk-YHKKCXGY.js";
 import {
   HISTORY_WINDOW_RUNS,
   IntelligenceService,
@@ -83,12 +84,13 @@ import {
   siteCrawlPages,
   siteCrawlSnapshots,
   trafficSources
-} from "./chunk-H6COEFVL.js";
+} from "./chunk-P2EFPLIO.js";
 import {
   RunKinds,
   SiteCrawlFetchStates,
   SiteCrawlIndexabilityReasons,
   SiteCrawlIndexabilityStates,
+  aeroPreviewResponseSchema,
   buildMeasurementExecutionIdentity,
   buildMeasurementRunManifestV1,
   buildSimpleMeasurementDefinition,
@@ -102,19 +104,1008 @@ import {
   factorStatusFromScore,
   measurementPlanV2ChecksumJson,
   measurementPlanV2Schema,
+  parseStoredMeasurementPlanAnyVersion,
   placementLinkDecision,
-  siteAuditPageFactorSchema
-} from "./chunk-L36TC6LB.js";
+  siteAuditPageFactorSchema,
+  wilsonInterval
+} from "./chunk-WLL7Q7JD.js";
 
 // src/demo-server.ts
 import { dirname, join as join2 } from "path";
 import { fileURLToPath } from "url";
 
+// src/demo/aero-preview.ts
+import { and, asc, desc, eq } from "drizzle-orm";
+
+// src/demo/summit-sweeps.ts
+var SUMMIT_SWEEP_COUNT = 6;
+var SUMMIT_ENGINES = ["openai", "gemini", "claude"];
+var RIVALS = {
+  roofcraft: { name: "RoofCraft", domain: "roofcraft.example", path: "/roof-replacement/", blurb: "A replacement contractor known for metal and shingle installs." },
+  everlast: { name: "Everlast Roofing", domain: "everlast-roofing.example", path: "/services/", blurb: "A repair and gutter company with a large emergency crew." }
+};
+var SUMMIT_COMPETITORS = Object.values(RIVALS).map((rival) => ({ domain: rival.domain, label: rival.name }));
+var SUMMIT_QUERIES = [
+  { key: "reviews", text: "Summit Roofing reviews", pages: ["/reviews/"], rivals: [], source: "https://home-services-reviews.example/roofers/", lead: "Recent homeowner reviews are mostly positive.", blurb: "Reviewers mention clear estimates, tidy crews and quick follow-up on warranty visits." },
+  { key: "near-me", text: "roof repair contractor near me", pages: ["/services/roof-repair/", "/service-areas/"], rivals: ["everlast", "roofcraft"], source: "https://local-contractor-directory.example/roofing/", lead: "Several roofers in the area handle repair work.", blurb: "A local roofer covering leak repairs, storm damage and inspections across two dozen towns." },
+  { key: "emergency-leak", text: "emergency roof leak repair", pages: ["/services/roof-repair/leak-repair/", "/services/roof-repair/emergency-tarping/"], rivals: ["everlast"], source: "https://homeowner-guides.example/roof-leaks/", lead: "For an active leak, look for a crew that can tarp the roof the same day.", blurb: "Offers emergency tarping and leak repair, with same-day visits in its service area." },
+  { key: "metal-installer", text: "best metal roof installer", pages: ["/services/roof-replacement/metal-roofing/", "/guides/metal-vs-asphalt-shingles/"], rivals: ["roofcraft"], source: "https://metal-roofing-council.example/find-an-installer/", lead: "Metal roofs need an installer with standing-seam experience.", blurb: "Installs standing-seam and metal shingle roofs and publishes a metal versus asphalt comparison." },
+  { key: "warranty", text: "Summit Roofing warranty", pages: ["/about/warranty/"], rivals: [], source: "https://homeowner-guides.example/roof-warranties/", lead: "Roofing warranties usually combine manufacturer and workmanship coverage.", blurb: "Backs replacements with a written workmanship warranty on top of the manufacturer coverage." },
+  { key: "replacement-cost", text: "how much does a roof replacement cost", pages: ["/guides/how-much-does-a-roof-replacement-cost/", "/financing/"], rivals: ["roofcraft"], source: "https://home-cost-report.example/roof-replacement/", lead: "Most full replacements land between 9,000 and 18,000 dollars, depending on size and material.", blurb: "Publishes a cost guide with typical price ranges and offers financing on full replacements." },
+  { key: "storm-claims", text: "storm damage roof repair and insurance claims", pages: ["/services/roof-repair/storm-damage/", "/guides/filing-a-roof-insurance-claim/"], rivals: ["everlast"], source: "https://homeowner-guides.example/storm-claims/", lead: "Photograph the damage before any repair and call your insurer early.", blurb: "Documents storm damage for insurance claims and joins the adjuster visit." },
+  { key: "asphalt-shingles", text: "asphalt shingle roof replacement", pages: ["/services/roof-replacement/asphalt-shingles/"], rivals: ["roofcraft"], source: "https://home-cost-report.example/asphalt-shingles/", lead: "Architectural shingles are the most common replacement choice.", blurb: "Replaces asphalt shingle roofs with a choice of architectural shingle lines." },
+  { key: "seamless-gutters", text: "seamless gutter installation", pages: ["/services/gutters/seamless-gutters/"], rivals: ["everlast"], source: "https://homeowner-guides.example/gutters/", lead: "Seamless gutters are formed on site, so they leak less at the joints.", blurb: "Installs seamless gutters and gutter guards, often alongside a roof replacement." },
+  { key: "pre-purchase-inspection", text: "roof inspection before buying a house", pages: ["/services/roof-inspection/real-estate-inspection/", "/guides/real-estate-roof-inspections/"], rivals: ["roofcraft", "everlast"], source: "https://home-buyer-checklist.example/roof-inspection/", lead: "A roof inspection before closing can surface repairs to negotiate.", blurb: "Runs pre-purchase roof inspections with photo reports for buyers and agents." }
+];
+var SUMMIT_BRANDED_QUERY_KEYS = ["reviews", "warranty"];
+var SUMMIT_ENGINE_PLANS = {
+  // Climbs steadily.
+  openai: {
+    mentioned: [2, 3, 3, 4, 5, 6],
+    mentionOrder: ["emergency-leak", "replacement-cost", "near-me", "storm-claims", "pre-purchase-inspection", "seamless-gutters", "asphalt-shingles", "metal-installer"],
+    cited: [1, 2, 2, 3, 4, 5],
+    citationOrder: ["replacement-cost", "storm-claims", "pre-purchase-inspection", "emergency-leak", "asphalt-shingles", "metal-installer", "seamless-gutters", "near-me"]
+  },
+  // Steady, then a dip and a recovery.
+  gemini: {
+    mentioned: [4, 4, 4, 2, 3, 5],
+    mentionOrder: ["near-me", "emergency-leak", "replacement-cost", "storm-claims", "seamless-gutters", "pre-purchase-inspection", "metal-installer", "asphalt-shingles"],
+    cited: [3, 3, 3, 1, 2, 3],
+    citationOrder: ["replacement-cost", "pre-purchase-inspection", "storm-claims", "metal-installer", "emergency-leak", "asphalt-shingles", "seamless-gutters", "near-me"]
+  },
+  // Swings from week to week.
+  claude: {
+    mentioned: [3, 1, 4, 2, 4, 3],
+    mentionOrder: ["emergency-leak", "replacement-cost", "storm-claims", "near-me", "pre-purchase-inspection", "asphalt-shingles", "seamless-gutters", "metal-installer"],
+    cited: [2, 1, 2, 1, 3, 2],
+    citationOrder: ["pre-purchase-inspection", "replacement-cost", "storm-claims", "emergency-leak", "asphalt-shingles", "near-me", "metal-installer", "seamless-gutters"]
+  }
+};
+var BRANDED_PLAN = {
+  reviews: {
+    openai: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
+    gemini: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
+    claude: { mentioned: [true, true, true, true, true, true], cited: [false, false, false, false, false, false] }
+  },
+  warranty: {
+    openai: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
+    gemini: { mentioned: [true, true, true, false, true, true], cited: [true, true, true, false, true, true] },
+    claude: { mentioned: [true, true, true, true, true, true], cited: [false, false, true, false, true, true] }
+  }
+};
+function isBranded(key) {
+  return SUMMIT_BRANDED_QUERY_KEYS.includes(key);
+}
+function summitAnswerPlan(sweep, engine, queryKey) {
+  if (isBranded(queryKey)) {
+    const plan2 = BRANDED_PLAN[queryKey][engine];
+    return { mentioned: plan2.mentioned[sweep], cited: plan2.cited[sweep] };
+  }
+  const plan = SUMMIT_ENGINE_PLANS[engine];
+  return {
+    mentioned: plan.mentionOrder.slice(0, plan.mentioned[sweep]).includes(queryKey),
+    cited: plan.citationOrder.slice(0, plan.cited[sweep]).includes(queryKey)
+  };
+}
+function summitAnswer(input) {
+  const { sweep, engine, queryIndex, displayName, domain } = input;
+  const query = SUMMIT_QUERIES[queryIndex];
+  const engineIndex = SUMMIT_ENGINES.indexOf(engine);
+  const plan = summitAnswerPlan(sweep, engine, query.key);
+  const rivals = plan.mentioned ? (sweep + engineIndex + queryIndex) % 2 === 0 ? query.rivals.slice(0, 1) : [] : query.rivals;
+  const entries = [
+    ...plan.mentioned ? [{ name: displayName, blurb: query.blurb }] : [],
+    ...rivals.map((key) => ({ name: RIVALS[key].name, blurb: RIVALS[key].blurb }))
+  ];
+  const answerText = isBranded(query.key) && !plan.mentioned ? `Fictional answer.
+
+I could not find published details for that company. ${query.lead} Most residential roofers offer 5 to 10 years of workmanship coverage.` : [
+    "Fictional answer.",
+    query.lead,
+    entries.map((entry, index) => `${index + 1}. **${entry.name}**: ${entry.blurb}`).join("\n"),
+    "Get two or three written estimates before you commit."
+  ].join("\n\n");
+  const citedRivals = rivals.filter((_, index) => (sweep + engineIndex + queryIndex + index) % 3 !== 0);
+  const citedUrls = [
+    ...plan.cited ? [`https://${domain}${query.pages[(sweep + engineIndex) % query.pages.length]}`] : [],
+    ...citedRivals.map((key) => `https://${RIVALS[key].domain}${RIVALS[key].path}`),
+    query.source
+  ];
+  const citedDomains = citedUrls.map((url) => new URL(url).hostname);
+  const normalized = {
+    provider: engine,
+    answerText,
+    citedDomains,
+    groundingSources: citedUrls.map((uri) => ({ uri, title: "" })),
+    searchQueries: [query.text],
+    retrievalStatus: "used"
+  };
+  const domains = effectiveDomains({ canonicalDomain: domain, ownedDomains: [domain] });
+  const brandNames = effectiveBrandNames({ displayName, canonicalDomain: domain, ownedDomains: [domain] });
+  const competitorDomains = SUMMIT_COMPETITORS.map((competitor) => competitor.domain);
+  return {
+    answerText,
+    answerMentioned: determineAnswerMentioned(answerText, brandNames, domains),
+    citationState: determineCitationState(normalized, domains),
+    citedDomains,
+    citedUrls,
+    competitorOverlap: computeCompetitorOverlap(normalized, competitorDomains),
+    recommendedCompetitors: extractRecommendedCompetitors(answerText, domains, citedDomains, competitorDomains, brandNames)
+  };
+}
+
+// src/demo/aero-preview.ts
+var ENGINE_ORDER = ["openai", "gemini", "claude"];
+var ENGINE_NAMES = { openai: "OpenAI", gemini: "Gemini", claude: "Claude" };
+var SUMMIT_TOPICS = {
+  "reviews": "Reviews",
+  "warranty": "Warranty",
+  "near-me": "Local repair",
+  "emergency-leak": "Emergency repair",
+  "metal-installer": "Metal roofing",
+  "replacement-cost": "Replacement cost",
+  "storm-claims": "Storm damage",
+  "asphalt-shingles": "Shingle replacement",
+  "seamless-gutters": "Gutters",
+  "pre-purchase-inspection": "Inspections"
+};
+var DAY = new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
+function formatPreviewDay(iso) {
+  return DAY.format(new Date(iso));
+}
+var engineName = (provider) => ENGINE_NAMES[provider] ?? provider;
+var quoted = (text) => `"${text}"`;
+var ratio = (numerator, denominator) => `${numerator}/${denominator}`;
+var percent = (numerator, denominator) => denominator === 0 ? 0 : Math.round(numerator / denominator * 100);
+var unique = (values) => [...new Set(values)];
+function listJoin(items, conjunction = "and") {
+  if (items.length <= 1) return items[0] ?? "";
+  return `${items.slice(0, -1).join(", ")} ${conjunction} ${items.at(-1)}`;
+}
+function engineOrder(left, right) {
+  const rank = (provider) => {
+    const index = ENGINE_ORDER.indexOf(provider);
+    return index === -1 ? ENGINE_ORDER.length : index;
+  };
+  return rank(left) - rank(right) || (left < right ? -1 : left > right ? 1 : 0);
+}
+function tally(answers) {
+  return {
+    mentioned: answers.filter((answer) => answer.mentioned).length,
+    cited: answers.filter((answer) => answer.cited).length,
+    total: answers.length
+  };
+}
+function withinNoise(before, after) {
+  const a = wilsonInterval(before.n, before.d);
+  const b = wilsonInterval(after.n, after.d);
+  if (!a || !b) return true;
+  return a.low <= b.high && b.low <= a.high;
+}
+function noisePhrase(within) {
+  return within ? "Within normal run-to-run noise." : "Bigger than normal run-to-run noise.";
+}
+function movement(current, previous, denominator) {
+  if (current === previous) return `${ratio(current, denominator)}, unchanged`;
+  return `${ratio(current, denominator)}, ${current > previous ? "up" : "down"} from ${ratio(previous, denominator)}`;
+}
+function step(name, args, result, durationMs, text) {
+  const tool = canonryMcpTools.find((candidate) => candidate.name === name);
+  if (!tool) throw new Error(`Aero preview names an unregistered tool: ${name}`);
+  const parsed = tool.inputSchema.safeParse(args);
+  if (!parsed.success) throw new Error(`Aero preview passes invalid arguments to ${name}: ${parsed.error.message}`);
+  const unknownKeys = Object.keys(args).filter((key) => !(key in parsed.data));
+  if (unknownKeys.length > 0) throw new Error(`Aero preview passes unknown arguments to ${name}: ${unknownKeys.join(", ")}`);
+  return { ...text ? { text } : {}, tool: { name, label: tool.title, arguments: args, result, durationMs } };
+}
+function recommendationClause(reason) {
+  if (!reason) return "";
+  const head = reason.split(/\s+[\u2014\u2013]\s+/)[0].trim();
+  const sentences = head.split(/(?<=\.)\s+/).filter(Boolean);
+  const last = (sentences.at(-1) ?? head).replace(/\.$/, "");
+  return last.charAt(0).toLowerCase() + last.slice(1);
+}
+function storedRecommendation(reasons) {
+  const clauses = reasons.map(recommendationClause).filter(Boolean);
+  if (clauses.length === 0) return "";
+  return `Stored recommendation${clauses.length === 1 ? "" : "s"}: ${clauses.join(", and ")}.`;
+}
+function loadFacts(db, project) {
+  const rows = db.select().from(runs).where(and(eq(runs.projectId, project.id), eq(runs.kind, "answer-visibility"), eq(runs.status, "completed"))).orderBy(asc(runs.createdAt), asc(runs.id)).all().filter((run) => run.trigger !== "probe");
+  const competitors2 = /* @__PURE__ */ new Map();
+  const properties = /* @__PURE__ */ new Map();
+  const sweeps = rows.map((run) => {
+    const classes = /* @__PURE__ */ new Map();
+    let planRevision = null;
+    if (run.measurementPlanVersionId) {
+      const version = db.select().from(measurementPlanVersions).where(eq(measurementPlanVersions.id, run.measurementPlanVersionId)).get();
+      if (!version) throw new Error(`Demo sweep ${run.id} names a missing plan revision`);
+      const plan = parseStoredMeasurementPlanAnyVersion(version.canonicalJson);
+      if (plan.schemaVersion !== 2) throw new Error(`Demo sweep ${run.id} is not measured by a portfolio plan`);
+      planRevision = version.revision;
+      for (const assignment of plan.assignments) classes.set(assignment.queryId, { queryClass: assignment.queryClass, targetKey: assignment.targetKey });
+      for (const group of plan.groups) {
+        const market = group.label.replace(/\s+market$/i, "");
+        for (const competitor of group.competitors) {
+          if (competitor.domain) competitors2.set(competitor.domain, { label: competitor.label, domain: competitor.domain });
+        }
+        for (const targetKey of group.targetKeys) {
+          const target = plan.targets.find((candidate) => candidate.stableKey === targetKey);
+          if (target) {
+            const pathPrefixes = target.urlMatchers.flatMap((matcher) => matcher.kind === "prefix" ? [matcher.pathPrefix] : []);
+            properties.set(targetKey, { key: targetKey, label: target.label, market, pathPrefixes });
+          }
+        }
+      }
+    } else {
+      const definition = db.select().from(simpleMeasurementDefinitions).where(eq(simpleMeasurementDefinitions.runId, run.id)).get();
+      if (!definition) throw new Error(`Demo sweep ${run.id} has no frozen measurement definition`);
+      for (const query of definition.definition.queries) {
+        classes.set(query.queryId, { queryClass: query.queryClass === "branded" || query.queryClass === "non-brand" ? query.queryClass : null, targetKey: null });
+      }
+      for (const competitor of definition.definition.competitors ?? []) competitors2.set(competitor.domain, { label: competitor.label, domain: competitor.domain });
+    }
+    const answers = db.select().from(querySnapshots).where(eq(querySnapshots.runId, run.id)).all().map((row) => {
+      const assigned = row.queryId ? classes.get(row.queryId) : void 0;
+      const citedUrls = row.citedUrls ?? [];
+      return {
+        queryId: row.queryId ?? row.queryText ?? "",
+        query: row.queryText ?? "",
+        provider: row.provider,
+        queryClass: assigned?.queryClass ?? null,
+        targetKey: assigned?.targetKey ?? null,
+        mentioned: row.answerMentioned === true,
+        cited: row.citationState === "cited",
+        named: [...competitors2.values()].filter((competitor) => (row.answerText ?? "").includes(competitor.label)).map((competitor) => competitor.label),
+        competitorCited: [...competitors2.values()].filter((competitor) => row.citedDomains.some((domain) => domain === competitor.domain || domain.endsWith(`.${competitor.domain}`))).map((competitor) => competitor.label),
+        citedDomains: row.citedDomains,
+        ownCitedPaths: citedUrls.flatMap((url) => {
+          const parsed = new URL(url);
+          return parsed.hostname === project.domain ? [parsed.pathname] : [];
+        })
+      };
+    });
+    const manifest = run.measurementManifest;
+    return {
+      id: run.id,
+      createdAt: run.createdAt,
+      planRevision,
+      executionChecksum: run.measurementExecutionIdentity?.checksum ?? null,
+      expectedAnswers: Array.isArray(manifest?.expectedSlots) ? manifest.expectedSlots.length : null,
+      answers
+    };
+  });
+  if (sweeps.length < 2) throw new Error(`Demo project ${project.name} needs two completed sweeps for the Aero preview`);
+  return { project, sweeps, latest: sweeps.at(-1), previous: sweeps.at(-2), competitors: [...competitors2.values()], properties };
+}
+function enginesOf(sweep) {
+  return unique(sweep.answers.map((answer) => answer.provider)).sort(engineOrder);
+}
+function ofClass(sweep, queryClass, provider) {
+  return sweep.answers.filter((answer) => answer.queryClass === queryClass && (provider === void 0 || answer.provider === provider));
+}
+function queryIdsOf(answers) {
+  return unique(answers.map((answer) => answer.queryId));
+}
+function byQuery(answers) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const answer of answers) grouped.set(answer.queryId, [...grouped.get(answer.queryId) ?? [], answer]);
+  return grouped;
+}
+function series(facts, queryClass, key, provider) {
+  return facts.sweeps.map((sweep) => tally(ofClass(sweep, queryClass, provider))[key]);
+}
+function summary(answers) {
+  const counts = tally(answers);
+  return {
+    queryCount: queryIdsOf(answers).length,
+    answerCount: counts.total,
+    mentionCoverage: { numerator: counts.mentioned, denominator: counts.total },
+    citationCoverage: { numerator: counts.cited, denominator: counts.total }
+  };
+}
+function providerRollup(sweep, queryClass) {
+  return Object.fromEntries(enginesOf(sweep).map((provider) => {
+    const counts = tally(ofClass(sweep, queryClass, provider));
+    return [provider, { mentioned: counts.mentioned, cited: counts.cited, answers: counts.total }];
+  }));
+}
+function namedInstead(answers) {
+  const missing = answers.filter((answer) => !answer.mentioned);
+  return unique(missing.flatMap((answer) => answer.named)).map((label) => ({
+    label,
+    engines: unique(missing.filter((answer) => answer.named.includes(label)).map((answer) => answer.provider)).sort(engineOrder)
+  }));
+}
+function link(label, path) {
+  return `[${label}](${path})`;
+}
+function summitTopic(query) {
+  const key = SUMMIT_QUERIES.find((candidate) => candidate.text === query)?.key;
+  return key ? SUMMIT_TOPICS[key] ?? null : null;
+}
+function summitStatus(facts) {
+  const { project, latest, sweeps } = facts;
+  const engines = enginesOf(latest);
+  const queryCount = queryIdsOf(latest.answers).length;
+  const branded = ofClass(latest, "branded");
+  const nonBrand = ofClass(latest, "non-brand");
+  const brandedCounts = tally(branded);
+  const nonBrandCounts = tally(nonBrand);
+  const nonBrandQueries = queryIdsOf(nonBrand).length;
+  const perEngine = engines.map((provider) => ({ provider, ...tally(ofClass(latest, "non-brand", provider)) }));
+  const unnamed = [...byQuery(nonBrand).values()].filter((answers) => answers.every((answer2) => !answer2.mentioned));
+  const unnamedRivals = unique(unnamed.flatMap((answers) => namedInstead(answers).map((entry) => entry.label)));
+  const allAnswered = engines.every((provider) => latest.answers.filter((answer2) => answer2.provider === provider).length === queryCount);
+  const weakest = [...perEngine].sort((left, right) => left.mentioned - right.mentioned);
+  const uniqueWeakest = weakest.length > 1 && weakest[0].mentioned < weakest[1].mentioned ? weakest[0] : null;
+  const brandedMisses = branded.filter((answer2) => !answer2.cited);
+  const brandedUnnamed = branded.filter((answer2) => !answer2.mentioned);
+  const attention = [];
+  if (unnamed.length > 0) {
+    const queries2 = listJoin(unnamed.map((answers) => quoted(answers[0].query)), "or");
+    const rivals = unnamedRivals.length > 0 ? ` ${listJoin(unnamedRivals)} ${unnamedRivals.length === 1 ? "is" : "are"} named ${unnamed.length === 1 ? "there" : `on ${unnamed.length === 2 ? "both" : "all of them"}`}.` : "";
+    attention.push(`- No engine names ${project.displayName} on ${queries2}.${rivals}`);
+  }
+  if (uniqueWeakest) attention.push(`- ${engineName(uniqueWeakest.provider)} is the weakest engine on non-brand, naming you on ${uniqueWeakest.mentioned} of ${uniqueWeakest.total}.`);
+  if (brandedUnnamed.length === 0 && brandedMisses.length > 0) {
+    attention.push(`- Branded mentions are complete. The ${brandedMisses.length === 1 ? "one branded gap is a citation" : "branded gaps are citations"}: ${listJoin(brandedMisses.map((answer2) => `${engineName(answer2.provider)} does not cite your site on ${quoted(answer2.query)}`))}.`);
+  }
+  const answer = [
+    `**Latest sweep: ${formatPreviewDay(latest.createdAt)}, completed.** ${listJoin(engines.map(engineName))} ${allAnswered ? `all answered all ${queryCount} queries` : "answered"}, ${latest.answers.length} answers in total. That makes ${sweeps.length} sweeps so far; the first ran on ${formatPreviewDay(sweeps[0].createdAt)}.`,
+    [
+      "| Queries | Mentioned | Cited |",
+      "|---|---|---|",
+      `| Branded (${queryIdsOf(branded).length}) | ${ratio(brandedCounts.mentioned, brandedCounts.total)} | ${ratio(brandedCounts.cited, brandedCounts.total)} |`,
+      `| Non-brand (${nonBrandQueries}) | ${ratio(nonBrandCounts.mentioned, nonBrandCounts.total)} (${percent(nonBrandCounts.mentioned, nonBrandCounts.total)}%) | ${ratio(nonBrandCounts.cited, nonBrandCounts.total)} (${percent(nonBrandCounts.cited, nonBrandCounts.total)}%) |`
+    ].join("\n"),
+    `Non-brand by engine, mentioned then cited: ${perEngine.map((entry) => `${engineName(entry.provider)} ${ratio(entry.mentioned, entry.total)} and ${ratio(entry.cited, entry.total)}`).join(", ")}.`,
+    ...attention.length > 0 ? [`**Needs attention**
+${attention.join("\n")}`] : [],
+    unnamed.length > 0 ? `Next: open ${unnamed.length === 1 ? "that query" : `those ${unnamed.length} queries`} and read the answers that name ${listJoin(unnamedRivals)}; that is the content your pages need to match. ${link("Open queries", `/projects/${project.name}/queries`)}` : `Next: keep the weekly sweep running and watch the weakest engine. ${link("Open queries", `/projects/${project.name}/queries`)}`
+  ].join("\n\n");
+  return {
+    id: "status",
+    steps: [
+      step("canonry_project_overview", { project: project.name }, {
+        latestRun: { run: { id: latest.id, kind: "answer-visibility", status: "completed", createdAt: latest.createdAt } },
+        health: {
+          runId: latest.id,
+          totalPairs: latest.answers.length,
+          mentionedPairs: tally(latest.answers).mentioned,
+          citedPairs: tally(latest.answers).cited,
+          providerBreakdown: Object.fromEntries(engines.map((provider) => {
+            const counts = tally(latest.answers.filter((item) => item.provider === provider));
+            return [provider, { mentioned: counts.mentioned, cited: counts.cited, total: counts.total }];
+          }))
+        }
+      }, 820, "Checking the latest sweep and which engines answered."),
+      step("canonry_visibility_report", { project: project.name, queryClass: "all" }, {
+        selection: { queryClass: "all", run: { id: latest.id } },
+        populations: [
+          { queryClass: "branded", summary: summary(branded) },
+          {
+            queryClass: "non-brand",
+            summary: summary(nonBrand),
+            providerRollup: providerRollup(latest, "non-brand"),
+            unnamedQueries: unnamed.map((answers) => ({ query: answers[0].query, namedInstead: namedInstead(answers).map((entry) => entry.label) }))
+          }
+        ]
+      }, 1140, "The overview pools branded and non-brand, so reading the classes separately.")
+    ],
+    answer
+  };
+}
+function summitChanges(facts) {
+  const { project, latest, previous, sweeps } = facts;
+  const sameQueries = queryIdsOf(latest.answers).sort().join("\n") === queryIdsOf(previous.answers).sort().join("\n");
+  const lines = [];
+  const reading = (queryClass, key) => {
+    const now = tally(ofClass(latest, queryClass));
+    const before2 = tally(ofClass(previous, queryClass));
+    return { now: now[key], before: before2[key], total: now.total, beforeTotal: before2.total };
+  };
+  const verdicts = [];
+  for (const [key, heading] of [["mentioned", "Mentions"], ["cited", "Citations"]]) {
+    const rows = [];
+    for (const [queryClass, label] of [["non-brand", "Non-brand"], ["branded", "Branded"]]) {
+      const value = reading(queryClass, key);
+      if (value.total === 0) continue;
+      let line = `- ${label}: ${movement(value.now, value.before, value.total)}.`;
+      if (value.now !== value.before) {
+        const within = withinNoise({ n: value.before, d: value.beforeTotal }, { n: value.now, d: value.total });
+        verdicts.push(within);
+        line += ` ${noisePhrase(within)}`;
+        const history = series(facts, queryClass, key);
+        if (key === "mentioned" && value.now === Math.max(...history) && history.slice(0, -1).every((item) => item < value.now)) {
+          line += ` It is the highest of the ${sweeps.length} sweeps (${history.join(", ")}).`;
+        }
+      }
+      rows.push(line);
+    }
+    lines.push(`**${heading}**
+${rows.join("\n")}`);
+  }
+  const queryState = (sweep) => new Map([...byQuery(sweep.answers)].map(([queryId, answers]) => [queryId, {
+    query: answers[0].query,
+    mentioned: answers.some((answer2) => answer2.mentioned),
+    cited: answers.some((answer2) => answer2.cited)
+  }]));
+  const before = queryState(previous);
+  const after = queryState(latest);
+  const diff = [...after].flatMap(([queryId, state]) => {
+    const prior = before.get(queryId);
+    if (!prior || prior.mentioned === state.mentioned && prior.cited === state.cited) return [];
+    return [{
+      query: state.query,
+      run1MentionState: prior.mentioned ? "mentioned" : "not-mentioned",
+      run2MentionState: state.mentioned ? "mentioned" : "not-mentioned",
+      run1State: prior.cited ? "cited" : "not-cited",
+      run2State: state.cited ? "cited" : "not-cited"
+    }];
+  });
+  const gainedMention = diff.filter((row) => row.run2MentionState === "mentioned" && row.run1MentionState !== "mentioned");
+  const gainedCitation = diff.filter((row) => row.run2State === "cited" && row.run1State !== "cited");
+  const lost = diff.filter((row) => row.run1MentionState === "mentioned" && row.run2MentionState !== "mentioned" || row.run1State === "cited" && row.run2State !== "cited");
+  const citationFirsts = gainedCitation.map((row) => {
+    const everCited = sweeps.slice(0, -1).some((sweep) => sweep.answers.some((answer2) => answer2.query === row.query && answer2.cited));
+    const citedBy = latest.answers.filter((answer2) => answer2.query === row.query && answer2.cited).map((answer2) => engineName(answer2.provider));
+    return `${quoted(row.query)} gained a citation${everCited ? "" : `, its first from any engine (${listJoin(citedBy)})`}`;
+  });
+  const flipParts = [
+    ...gainedMention.map((row) => `${quoted(row.query)} gained a mention`),
+    ...citationFirsts
+  ];
+  const flips = flipParts.length > 0 ? `At query level, ${listJoin(flipParts)}. ${lost.length === 0 ? "No query lost either signal." : `${listJoin(lost.map((row) => quoted(row.query)))} lost a signal.`}` : "No query changed state at query level.";
+  const climbs = enginesOf(latest).map((provider) => ({
+    provider,
+    mentions: series(facts, "non-brand", "mentioned", provider),
+    citations: series(facts, "non-brand", "cited", provider),
+    total: tally(ofClass(latest, "non-brand", provider)).total
+  })).filter((entry) => entry.mentions.every((value, index) => index === 0 || value >= entry.mentions[index - 1]) && entry.mentions.at(-1) > entry.mentions[0]).sort((left, right) => right.mentions.at(-1) - right.mentions[0] - (left.mentions.at(-1) - left.mentions[0]));
+  const climb = climbs.at(0);
+  const allWithin = verdicts.every(Boolean);
+  let trend = allWithin ? "Nothing between these two sweeps is bigger than normal run-to-run noise." : "At least one change is bigger than normal run-to-run noise.";
+  if (climb) {
+    const firstToLast = withinNoise({ n: climb.mentions[0], d: climb.total }, { n: climb.mentions.at(-1), d: climb.total });
+    trend += ` The direction worth watching is ${engineName(climb.provider)}: its non-brand mentions have not dropped in ${sweeps.length} sweeps (${climb.mentions.join(", ")} of ${climb.total}), and citations went from ${climb.citations[0]} to ${climb.citations.at(-1)} of ${climb.total}.`;
+    trend += firstToLast ? ` Even first to last is within noise at ${climb.total} answers a sweep, so treat it as a direction to confirm, not a win.` : ` First to last is bigger than noise at ${climb.total} answers a sweep.`;
+  }
+  const nextParts = [
+    ...climb ? [`let the next sweep land before calling the ${engineName(climb.provider)} climb real`] : ["let the next sweep land before acting on any single move"],
+    ...gainedCitation[0] ? [`check that the new ${quoted(gainedCitation[0].query)} citation holds`] : []
+  ];
+  const answer = [
+    `**${formatPreviewDay(latest.createdAt)} vs ${formatPreviewDay(previous.createdAt)}${sameQueries ? `: the same ${queryIdsOf(latest.answers).length} queries on both sweeps` : ""}.**`,
+    ...lines,
+    flips,
+    trend,
+    `Next: ${nextParts.join(", and ")}. ${link("Open queries", `/projects/${project.name}/queries`)}`
+  ].join("\n\n");
+  const populations = ["branded", "non-brand"].map((queryClass) => {
+    const now = summary(ofClass(latest, queryClass));
+    const prior = tally(ofClass(previous, queryClass));
+    return {
+      queryClass,
+      summary: now,
+      comparison: {
+        previousRun: { id: previous.id, createdAt: previous.createdAt },
+        mentionCoverage: { previous: { numerator: prior.mentioned, denominator: prior.total } },
+        citationCoverage: { previous: { numerator: prior.cited, denominator: prior.total } }
+      },
+      ...queryClass === "non-brand" ? { trend: { runs: sweeps.map((sweep) => sweep.id), mentioned: series(facts, "non-brand", "mentioned"), cited: series(facts, "non-brand", "cited"), answers: tally(ofClass(latest, "non-brand")).total } } : {}
+    };
+  });
+  const steps = [
+    step("canonry_visibility_report", { project: project.name, queryClass: "all" }, {
+      selection: { queryClass: "all", run: { id: latest.id } },
+      populations
+    }, 1060, `Comparing the ${formatPreviewDay(latest.createdAt)} sweep with ${formatPreviewDay(previous.createdAt)}, branded and non-brand kept apart.`),
+    step("canonry_snapshots_diff", { project: project.name, run1: previous.id, run2: latest.id }, { run1: previous.id, run2: latest.id, changed: diff }, 540, "Checking which queries flipped.")
+  ];
+  if (climb) {
+    steps.push(step("canonry_visibility_report", { project: project.name, queryClass: "non-brand", provider: climb.provider }, {
+      selection: { queryClass: "non-brand", provider: climb.provider, run: { id: latest.id } },
+      trend: { mentioned: climb.mentions, cited: climb.citations, answers: climb.total }
+    }, 910, `${engineName(climb.provider)} has moved the most, so reading its trend.`));
+  }
+  return { id: "changes", steps, answer };
+}
+function summitGaps(facts) {
+  const { project, latest } = facts;
+  const nonBrand = ofClass(latest, "non-brand");
+  const groups = [...byQuery(nonBrand).values()];
+  const engines = enginesOf(latest);
+  const unnamed = groups.filter((answers) => answers.every((answer2) => !answer2.mentioned));
+  const partial = groups.filter((answers) => answers.some((answer2) => answer2.mentioned) && answers.some((answer2) => !answer2.mentioned));
+  const topicOf = (query) => summitTopic(query) ?? query;
+  const rivals = unique(unnamed.flatMap((answers) => namedInstead(answers).map((entry) => entry.label)));
+  const rows = unnamed.map((answers) => {
+    const query = answers[0].query;
+    const instead = namedInstead(answers).map((entry) => `${entry.label}, by ${entry.engines.length} of ${answers.length} engines`).join("; ") || "no tracked competitor";
+    const citedBy = answers.filter((answer2) => answer2.cited).map((answer2) => engineName(answer2.provider));
+    return `| ${topicOf(query)} | ${query} | ${instead} | ${citedBy.length} of ${answers.length}${citedBy.length > 0 ? ` (${listJoin(citedBy)})` : ""} |`;
+  });
+  const readButUnnamed = unnamed.flatMap((answers) => answers.filter((answer2) => answer2.cited && answer2.ownCitedPaths.length > 0).map((answer2) => `On ${quoted(answer2.query)}, ${engineName(answer2.provider)} cites ${answer2.ownCitedPaths[0]} without naming ${project.displayName}, so the page is read but the brand does not come through.`));
+  const partialLines = partial.map((answers) => {
+    const missing = answers.filter((answer2) => !answer2.mentioned);
+    const who = listJoin(missing.map((answer2) => engineName(answer2.provider)));
+    const instead = unique(missing.flatMap((answer2) => answer2.named));
+    const stillCited = missing.every((answer2) => answer2.cited);
+    return `- ${topicOf(answers[0].query)}, ${quoted(answers[0].query)}: ${who} ${instead.length > 0 ? `name${missing.length === 1 ? "s" : ""} ${listJoin(instead)} instead` : `do${missing.length === 1 ? "es" : ""} not name you`}${stillCited ? `, though ${missing.length === 1 ? "it still cites" : "both still cite"} your site` : ""}.`;
+  });
+  const pages = unique(unnamed.map((answers) => {
+    const cited = answers.find((answer2) => answer2.ownCitedPaths.length > 0)?.ownCitedPaths[0];
+    return cited ?? SUMMIT_QUERIES.find((candidate) => candidate.text === answers[0].query)?.pages[0];
+  }).filter((page) => Boolean(page)));
+  const answer = unnamed.length === 0 ? `**Every non-brand query is named by at least one engine on ${formatPreviewDay(latest.createdAt)}.**
+
+${partialLines.join("\n")}
+
+Next: work the partial gaps above. ${link("Open queries", `/projects/${project.name}/queries`)}` : [
+    `**${unnamed.length} of ${groups.length} non-brand queries are named by no engine on ${formatPreviewDay(latest.createdAt)}.** ${rivals.length === 1 ? `${rivals[0]} takes ${unnamed.length === 1 ? "it" : unnamed.length === 2 ? "both" : "all of them"}.` : ""}`.trim(),
+    ["| Topic | Query | Named instead | Your site cited |", "|---|---|---|---|", ...rows].join("\n"),
+    ...readButUnnamed,
+    ...partialLines.length > 0 ? [`Partial gaps, where some engines name you and others do not:
+${partialLines.join("\n")}`] : [],
+    `Next: make ${project.displayName} and the service explicit on ${listJoin(pages)}, then check ${unnamed.length === 1 ? "the query" : unnamed.length === 2 ? "both queries" : "these queries"} on the next sweep. ${link("Open queries", `/projects/${project.name}/queries`)}`
+  ].join("\n\n");
+  const queryRows = groups.map((answers) => ({
+    query: answers[0].query,
+    mentionedBy: answers.filter((answer2) => answer2.mentioned).map((answer2) => answer2.provider).sort(engineOrder),
+    citedBy: answers.filter((answer2) => answer2.cited).map((answer2) => answer2.provider).sort(engineOrder)
+  }));
+  const missingAnswers = nonBrand.filter((answer2) => !answer2.mentioned).sort((left, right) => left.query.localeCompare(right.query) || engineOrder(left.provider, right.provider)).map((answer2) => ({
+    query: answer2.query,
+    provider: answer2.provider,
+    answerMentioned: false,
+    citationState: answer2.cited ? "cited" : "not-cited",
+    recommendedCompetitors: answer2.named
+  }));
+  return {
+    id: "gaps",
+    steps: [
+      step("canonry_visibility_report", { project: project.name, queryClass: "non-brand" }, {
+        selection: { queryClass: "non-brand", run: { id: latest.id } },
+        engines,
+        queries: queryRows
+      }, 980, "Reading the latest non-brand query rows."),
+      step("canonry_run_get", { runId: latest.id }, { id: latest.id, status: "completed", snapshots: missingAnswers }, 690, "Pulling the answers that leave you out to see who they name.")
+    ],
+    answer
+  };
+}
+function summitInsights(db, facts) {
+  const { project, latest, sweeps } = facts;
+  const active = db.select().from(insights).where(and(eq(insights.projectId, project.id), eq(insights.dismissed, false))).orderBy(desc(insights.createdAt), asc(insights.id)).all();
+  const severe = active.filter((row) => row.severity === "high" || row.severity === "critical");
+  const fromLatest = active.filter((row) => row.runId === latest.id);
+  const medium = fromLatest.filter((row) => row.severity === "medium");
+  const low = fromLatest.filter((row) => row.severity === "low");
+  if (severe.length > 0) throw new Error("The Summit Aero preview assumes no high or critical insight; rewrite its insights turn");
+  const gaps = medium.filter((row) => row.type === "persistent-gap");
+  const gains = medium.filter((row) => row.type === "competitor-gained");
+  const firsts = medium.filter((row) => row.type === "first-citation");
+  const latestByQuery = byQuery(latest.answers.filter((answer2) => answer2.queryClass !== null));
+  const answersFor = (query) => [...latestByQuery.values()].find((answers) => answers[0].query === query) ?? [];
+  const previousFor = (query) => facts.previous.answers.filter((answer2) => answer2.query === query);
+  const sharedSource = (answers) => {
+    const own = project.domain;
+    const competitorDomains = new Set(facts.competitors.map((competitor) => competitor.domain));
+    const candidates = unique(answers.flatMap((answer2) => answer2.citedDomains)).filter((domain) => domain !== own && !competitorDomains.has(domain));
+    return candidates.find((domain) => answers.every((answer2) => answer2.citedDomains.includes(domain))) ?? null;
+  };
+  const ranked = [...gaps].sort((left, right) => {
+    const score = (row) => {
+      const answers = answersFor(row.query);
+      return (answers.every((answer2) => !answer2.mentioned) ? 0 : 2) + (gains.some((gain) => gain.query === row.query) ? 0 : 1);
+    };
+    return score(left) - score(right);
+  }).slice(0, 3);
+  const items = ranked.map((row, index) => {
+    const answers = answersFor(row.query);
+    const mentionedBy = answers.filter((answer2) => answer2.mentioned).map((answer2) => answer2.provider).sort(engineOrder);
+    const gain = gains.find((candidate) => candidate.query === row.query);
+    const parts = [];
+    if (mentionedBy.length === 0) {
+      const instead = namedInstead(answers);
+      const everMentioned = sweeps.some((sweep) => sweep.answers.some((answer2) => answer2.query === row.query && answer2.mentioned));
+      parts.push(`No engine names ${project.displayName} on it${everMentioned ? "" : ` in any of the ${sweeps.length} sweeps`}${instead.length > 0 ? `, and ${listJoin(instead.map((entry) => entry.engines.length === answers.length ? `all ${answers.length} engines name ${entry.label}` : `${listJoin(entry.engines.map(engineName))} name${entry.engines.length === 1 ? "s" : ""} ${entry.label}`))}` : ""}.`);
+    } else {
+      const newly = mentionedBy.filter((provider) => !previousFor(row.query).some((answer2) => answer2.provider === provider && answer2.mentioned));
+      parts.push(newly.length === mentionedBy.length ? `${listJoin(mentionedBy.map(engineName))} started naming you on this sweep, but no engine cites you.` : `${listJoin(mentionedBy.map(engineName))} name${mentionedBy.length === 1 ? "s" : ""} you, but no engine cites you.`);
+      const rivalsCited = unique(answers.flatMap((answer2) => answer2.competitorCited));
+      for (const rival of rivalsCited) {
+        const citing = answers.filter((answer2) => answer2.competitorCited.includes(rival)).map((answer2) => engineName(answer2.provider));
+        if (!gain) parts.push(`${listJoin(citing)} cite${citing.length === 1 ? "s" : ""} ${rival} instead.`);
+      }
+      const source = sharedSource(answers);
+      if (source) parts.push(`Every answer cites ${source}, so check how that site covers you.`);
+    }
+    const stored = storedRecommendation([gain?.recommendation?.reason, row.recommendation?.reason]);
+    const pages = mentionedBy.length === 0 ? SUMMIT_QUERIES.find((candidate) => candidate.text === row.query)?.pages ?? [] : [];
+    const title = gain ? `${quoted(row.query)}: uncited for ${row.title.match(/for (\d+) runs/)?.[1] ?? "several"} runs, and ${facts.competitors.find((competitor) => competitor.domain === gain.cause?.competitorDomain)?.label ?? gain.cause?.competitorDomain ?? "a competitor"} just earned a citation there` : row.title;
+    return `${index + 1}. **${title}.** ${parts.join(" ")} ${stored}${pages.length > 0 ? ` Start with ${listJoin(pages)}.` : ""}`;
+  });
+  const win = firsts.at(0);
+  const winLine = win ? `The win: ${quoted(win.query)} got its first citation from any engine (${engineName(win.provider)}). ${storedRecommendation([win.recommendation?.reason])}` : null;
+  const firstUnnamed = ranked.find((row) => answersFor(row.query).every((answer2) => !answer2.mentioned));
+  const answer = [
+    `None of the ${active.length} active insights is high or critical, so I ranked the medium ones from the latest sweep. The ${formatPreviewDay(latest.createdAt)} sweep added ${fromLatest.length}, ${medium.length} medium and ${low.length} low, and the medium ones come down to ${items.length} issues${win ? " plus one win" : ""}.`,
+    items.join("\n"),
+    ...winLine ? [winLine] : [],
+    `Next: ${firstUnnamed ? `start with the ${quoted(firstUnnamed.query)} audit, since it is the only one of the ${items.length} where no engine names you` : "start with the first item"}. ${link("Open queries", `/projects/${project.name}/queries`)}`
+  ].join("\n\n");
+  return {
+    id: "insights",
+    steps: [
+      step("canonry_insights_list", { project: project.name }, {
+        active: active.length,
+        highOrCritical: severe.length,
+        latestSweep: { runId: latest.id, count: fromLatest.length, medium: medium.length, low: low.length },
+        medium: medium.map((row) => ({ id: row.id, type: row.type, title: row.title, provider: row.provider, recommendation: row.recommendation?.action ?? null, ...row.cause?.cause ? { cause: row.cause.cause } : {} }))
+      }, 470, "Listing active insights."),
+      step("canonry_run_get", { runId: latest.id }, {
+        id: latest.id,
+        status: "completed",
+        snapshots: ranked.flatMap((row) => answersFor(row.query).sort((left, right) => engineOrder(left.provider, right.provider)).map((answer2) => ({
+          query: answer2.query,
+          provider: answer2.provider,
+          answerMentioned: answer2.mentioned,
+          citationState: answer2.cited ? "cited" : "not-cited",
+          recommendedCompetitors: answer2.named,
+          citedDomains: answer2.citedDomains
+        })))
+      }, 730, "All medium, so checking the answers behind each one before ranking them.")
+    ],
+    answer
+  };
+}
+function shortPropertyLabel(property) {
+  const prefix = `Harbor ${property.market} `;
+  return property.label.startsWith(prefix) ? property.label.slice(prefix.length) : property.label;
+}
+function markets(facts) {
+  return unique([...facts.properties.values()].map((property) => property.market));
+}
+function marketOf(facts, answer) {
+  return answer.targetKey ? facts.properties.get(answer.targetKey)?.market ?? null : null;
+}
+function loadDeadLinks(db, facts) {
+  const { project } = facts;
+  const audit = db.select().from(runs).where(and(eq(runs.projectId, project.id), eq(runs.kind, "site-audit"), eq(runs.status, "completed"))).orderBy(desc(runs.createdAt), desc(runs.id)).get();
+  if (!audit) return null;
+  const snapshot = db.select().from(siteCrawlSnapshots).where(and(eq(siteCrawlSnapshots.projectId, project.id), eq(siteCrawlSnapshots.runId, audit.id))).get();
+  const findings = db.select().from(siteCrawlFindings).where(and(eq(siteCrawlFindings.projectId, project.id), eq(siteCrawlFindings.runId, audit.id), eq(siteCrawlFindings.findingType, "dead-link"))).orderBy(asc(siteCrawlFindings.findingKey)).all();
+  if (!snapshot || findings.length === 0) return null;
+  const targets = findings.map((finding) => finding.targetNodeKey ?? "");
+  const sources = unique(findings.map((finding) => finding.sourceNodeKey ?? ""));
+  const tails = targets.map((target) => target.split("/").filter(Boolean).at(-1) ?? "");
+  const owners = sources.map((source) => [...facts.properties.values()].find((property) => property.pathPrefixes.some((prefix) => source.startsWith(`${prefix}/`)))?.key);
+  return {
+    state: snapshot.deadLinkState,
+    checked: snapshot.deadLinksChecked,
+    found: snapshot.deadLinksFound,
+    sources,
+    targets,
+    statusCodes: unique(findings.map((finding) => Number(finding.evidence.statusCode)).filter(Number.isFinite)),
+    sharedTarget: tails[0] && tails.every((tail) => tail === tails[0]) ? tails[0] : null,
+    onePerPropertyOffersPage: sources.length === findings.length && sources.length === facts.properties.size && sources.every((source) => source.endsWith("/offers/")) && owners.every(Boolean) && unique(owners).length === owners.length
+  };
+}
+function deadLinkStep(project, deadLinks, text) {
+  return step("canonry_technical_aeo_dead_links", { project: project.name }, {
+    state: deadLinks.state,
+    checked: deadLinks.checked,
+    found: deadLinks.found,
+    deadLinks: deadLinks.targets.slice(0, 2).map((target, index) => ({ sourceNodeKey: deadLinks.sources[index], targetNodeKey: target, evidence: { statusCode: deadLinks.statusCodes[0] } }))
+  }, 610, text);
+}
+function deadLinkDetail(deadLinks) {
+  const where = deadLinks.onePerPropertyOffersPage ? "one on each property's offers page" : `on ${deadLinks.sources.length} pages`;
+  const codes = deadLinks.statusCodes.join(" or ");
+  const what = deadLinks.sharedTarget ? `all pointing to an ${deadLinks.sharedTarget} page that returns ${codes}` : `all returning ${codes}`;
+  return `${where}, ${what}`;
+}
+function harborStatus(facts, deadLinks) {
+  const { project, latest } = facts;
+  const engines = enginesOf(latest);
+  const branded = ofClass(latest, "branded");
+  const nonBrand = ofClass(latest, "non-brand");
+  const queryCount = queryIdsOf(latest.answers).length;
+  const allAnswered = engines.every((provider) => latest.answers.filter((answer2) => answer2.provider === provider).length === queryCount);
+  const together = latest.answers.every((answer2) => answer2.mentioned === answer2.cited);
+  const reached = (answers) => unique(answers.filter((answer2) => answer2.mentioned).map((answer2) => answer2.targetKey)).length;
+  const propertyCount = facts.properties.size;
+  const row = (label, answers) => {
+    const counts = tally(answers);
+    return `| ${label} (${queryIdsOf(answers).length}) | ${ratio(counts.mentioned, counts.total)} | ${ratio(counts.cited, counts.total)} | ${engines.map((provider) => {
+      const engine = tally(answers.filter((answer2) => answer2.provider === provider));
+      return ratio(engine.mentioned, engine.total);
+    }).join(" | ")} |`;
+  };
+  const dropped = engines.map((provider) => ({ provider, answers: nonBrand.filter((answer2) => answer2.provider === provider) })).filter((entry) => entry.answers.length > 0 && entry.answers.every((answer2) => !answer2.mentioned));
+  const attention = [
+    ...dropped.map((entry) => {
+      const instead = namedInstead(entry.answers);
+      const top = instead.sort((left, right) => right.engines.length - left.engines.length).at(0);
+      const count = top ? entry.answers.filter((answer2) => answer2.named.includes(top.label)).length : 0;
+      return `- ${engineName(entry.provider)} named Harbor on 0 of ${entry.answers.length} non-brand queries${top ? ` and named ${top.label} on ${count === entry.answers.length ? `all ${count}` : count} instead` : ""}.`;
+    }),
+    ...deadLinks ? [`- The site audit found ${deadLinks.found} dead links, ${deadLinkDetail(deadLinks)}.`] : []
+  ];
+  const answer = [
+    `**Latest sweep: ${formatPreviewDay(latest.createdAt)}, complete.** ${latest.expectedAnswers !== null ? `${latest.answers.length} of ${latest.expectedAnswers} expected answers came back: ` : ""}${listJoin(engines.map(engineName))} ${allAnswered ? `each answered all ${queryCount} queries` : "answered"} for ${propertyCount} properties in ${listJoin(markets(facts))}.`,
+    [
+      `| Queries | Mentioned | Cited | ${engines.map(engineName).join(" | ")} |`,
+      `|---|---|---|${engines.map(() => "---").join("|")}|`,
+      row("Branded", branded),
+      row("Non-brand", nonBrand)
+    ].join("\n"),
+    `Engine columns count mentions.${together ? " In this sample every answer that names a property also cites it, so the two signals match." : ""}${reached(branded) === propertyCount && reached(nonBrand) === propertyCount ? ` All ${propertyCount} properties were named in both classes.` : ""}`,
+    ...attention.length > 0 ? [`**Needs attention**
+${attention.join("\n")}`] : [],
+    `Next: ${[
+      ...dropped[0] ? [`read ${engineName(dropped[0].provider)}'s non-brand answers in one market`] : [],
+      ...deadLinks ? [`remove or redirect the broken link on all ${deadLinks.sources.length} ${deadLinks.onePerPropertyOffersPage ? "offers pages" : "pages"}`] : []
+    ].join(", and ") || "keep the weekly sweep running"}. ${link("Open portfolio", `/projects/${project.name}/portfolio`)}`
+  ].join("\n\n");
+  const steps = [
+    step("canonry_measurement_data_quality", { project: project.name, runId: latest.id }, {
+      run: { state: "complete", displayedRunId: latest.id, planRevision: latest.planRevision, completedAt: latest.createdAt },
+      completeness: { expected: latest.expectedAnswers, answered: latest.answers.length, missing: Math.max(0, (latest.expectedAnswers ?? latest.answers.length) - latest.answers.length) },
+      comparison: { previousDisplayedRunId: facts.previous.id }
+    }, 520, "Checking that the latest sweep is complete before reading it."),
+    step("canonry_visibility_report", { project: project.name, queryClass: "all" }, {
+      selection: { queryClass: "all", run: { id: latest.id } },
+      populations: ["branded", "non-brand"].map((queryClass) => ({
+        queryClass,
+        summary: { ...summary(ofClass(latest, queryClass)), propertyReach: { numerator: reached(ofClass(latest, queryClass)), denominator: propertyCount } },
+        providerRollup: providerRollup(latest, queryClass)
+      }))
+    }, 1210, "Reading branded and non-brand separately, with the engine split.")
+  ];
+  if (deadLinks) steps.push(deadLinkStep(project, deadLinks, "Checking the latest site audit for anything broken."));
+  return { id: "status", steps, answer };
+}
+function harborChanges(facts) {
+  const { project, latest, previous, sweeps } = facts;
+  const engines = enginesOf(latest);
+  const together = [latest, previous].every((sweep) => sweep.answers.every((answer2) => answer2.mentioned === answer2.cited));
+  const sameIdentity = latest.planRevision === previous.planRevision && latest.executionChecksum !== null && latest.executionChecksum === previous.executionChecksum;
+  const propertyMentions = (sweep, queryClass) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const answer2 of ofClass(sweep, queryClass)) if (answer2.targetKey && answer2.mentioned) counts.set(answer2.targetKey, (counts.get(answer2.targetKey) ?? 0) + 1);
+    return counts;
+  };
+  const changedProperties = (queryClass) => {
+    const now = propertyMentions(latest, queryClass);
+    const before = propertyMentions(previous, queryClass);
+    return [...facts.properties.values()].filter((property) => (now.get(property.key) ?? 0) !== (before.get(property.key) ?? 0)).map((property) => ({
+      targetKey: property.key,
+      label: property.label,
+      previous: before.get(property.key) ?? 0,
+      current: now.get(property.key) ?? 0,
+      engines: engines.length
+    }));
+  };
+  let usualMoves = 0;
+  const beyondDetail = /* @__PURE__ */ new Map();
+  const classLines = ["non-brand", "branded"].map((queryClass) => {
+    const now = tally(ofClass(latest, queryClass));
+    const before = tally(ofClass(previous, queryClass));
+    const label = queryClass === "branded" ? "Branded" : "Non-brand";
+    const perEngine = engines.map((provider) => ({
+      provider,
+      history: series(facts, queryClass, "mentioned", provider),
+      total: tally(ofClass(latest, queryClass, provider)).total
+    }));
+    const moves = perEngine.filter((entry) => entry.history.at(-1) !== entry.history.at(-2));
+    for (const entry of moves) {
+      const prior = entry.history.slice(0, -1);
+      const value = entry.history.at(-1);
+      const outside = value < Math.min(...prior) || value > Math.max(...prior);
+      if (!outside) usualMoves += 1;
+      else beyondDetail.set(`${entry.provider}:${queryClass}`, { provider: entry.provider, queryClass, history: entry.history, previousLow: Math.min(...prior), previousHigh: Math.max(...prior), total: entry.total });
+    }
+    const engineMoves = moves.map((entry) => `${engineName(entry.provider)} ${entry.history.at(-1) < entry.history.at(-2) ? "fell" : "rose"} from ${ratio(entry.history.at(-2), entry.total)} to ${ratio(entry.history.at(-1), entry.total)}`);
+    const changed = changedProperties(queryClass);
+    const totals = series(facts, queryClass, "mentioned");
+    const alternates = totals.length >= 4 && totals.every((value, index) => index < 2 || value === totals[index - 2]) && totals[0] !== totals[1];
+    let line = `**${label}:** `;
+    if (now.mentioned === before.mentioned) {
+      line += `${ratio(now.mentioned, now.total)} on both sweeps`;
+      line += engineMoves.length > 0 ? `, but the engine mix changed. ${engineMoves.join("; ")}.` : ".";
+    } else {
+      line += `${movement(now.mentioned, before.mentioned, now.total)}. ${noisePhrase(withinNoise({ n: before.mentioned, d: before.total }, { n: now.mentioned, d: now.total }))}`;
+      if (alternates) line += ` The ${label.toLowerCase()} total has alternated every sweep: ${totals.join(", ")}.`;
+      if (engineMoves.length > 0) line += ` ${engineMoves.join("; ")}.`;
+    }
+    if (changed.length === 0) {
+      line += " No property changed.";
+    } else {
+      const uniform = changed.every((property) => property.previous === changed[0].previous && property.current === changed[0].current);
+      const marketList = markets(facts);
+      const perMarket = marketList.map((market) => changed.filter((property) => facts.properties.get(property.targetKey)?.market === market).map((property) => shortPropertyLabel(facts.properties.get(property.targetKey))).sort().join("|"));
+      const who = perMarket.every((value) => value !== "" && value === perMarket[0]) ? `the ${listJoin(perMarket[0].split("|"))} in each of the ${marketList.length} markets` : listJoin(changed.map((property) => property.label));
+      line += uniform ? ` ${changed.length} ${changed.length === 1 ? "property" : "properties"} went from ${changed[0].previous} of ${engines.length} engines to ${changed[0].current} of ${engines.length}: ${who}.` : ` ${changed.length} ${changed.length === 1 ? "property" : "properties"} changed: ${who}.`;
+    }
+    return line;
+  });
+  const detail = [...beyondDetail.values()];
+  let noise = "";
+  if (detail.length > 0) {
+    noise = `**Bigger than the usual swing:** only ${listJoin(detail.map((entry) => `${engineName(entry.provider)} on ${entry.queryClass}`))}. ${detail.map((entry) => `Its series over ${sweeps.length} sweeps is ${entry.history.join(", ")}, so ${entry.history.at(-1)} is ${entry.history.at(-1) < entry.previousLow ? `below its previous low of ${entry.previousLow}` : `above its previous high of ${entry.previousHigh}`}`).join(". ")}.`;
+    if (usualMoves > 0) noise += ` Every other engine move stays inside the range that engine has swung through over ${sweeps.length} sweeps, so it is the usual swing, even though a Wilson interval at ${detail[0].total} answers would flag it.`;
+  } else {
+    noise = "Every engine stayed inside the range it has swung through before, so nothing here is bigger than the usual swing.";
+  }
+  const worst = detail.at(0);
+  const worstCompetitor = worst ? namedInstead(ofClass(latest, worst.queryClass, worst.provider))[0]?.label : void 0;
+  const answer = [
+    `**${formatPreviewDay(latest.createdAt)} vs ${formatPreviewDay(previous.createdAt)}${sameIdentity ? `: same plan revision (${latest.planRevision}) and the same engines and models on both sweeps` : ""}.**${together ? " In this sample every answer that names a property also cites it, so the citation numbers match the mention numbers below." : ""}`,
+    ...classLines,
+    noise,
+    `Next: ${worst ? `confirm ${engineName(worst.provider)} ${worst.queryClass} on the next sweep before changing pages${worstCompetitor ? `; if it stays at ${worst.history.at(-1)}, compare the ${worstCompetitor} pages it cites with your market pages` : ""}` : "keep the weekly sweep running"}. ${link("Open portfolio", `/projects/${project.name}/portfolio`)}`
+  ].join("\n\n");
+  const changesResult = (queryClass) => {
+    const now = tally(ofClass(latest, queryClass));
+    const before = tally(ofClass(previous, queryClass));
+    return {
+      current: { displayedRunId: latest.id, planRevision: latest.planRevision },
+      comparison: {
+        previous: { displayedRunId: previous.id, planRevision: previous.planRevision },
+        sameExecutionIdentity: sameIdentity,
+        metrics: {
+          mentionCoverage: { previous: { numerator: before.mentioned, denominator: before.total }, current: { numerator: now.mentioned, denominator: now.total } },
+          citationCoverage: { previous: { numerator: before.cited, denominator: before.total }, current: { numerator: now.cited, denominator: now.total } }
+        },
+        changedProperties: changedProperties(queryClass).map((property) => ({ label: property.label, mentioned: { previous: `${property.previous}/${property.engines}`, current: `${property.current}/${property.engines}` } }))
+      }
+    };
+  };
+  return {
+    id: "changes",
+    steps: [
+      step("canonry_measurement_changes", { project: project.name, queryClass: "non-brand" }, changesResult("non-brand"), 780, `Comparing ${formatPreviewDay(latest.createdAt)} with ${formatPreviewDay(previous.createdAt)}, non-brand first.`),
+      step("canonry_measurement_changes", { project: project.name, queryClass: "branded" }, changesResult("branded"), 690),
+      step("canonry_visibility_report", { project: project.name, queryClass: "all" }, {
+        selection: { queryClass: "all" },
+        trend: Object.fromEntries(["branded", "non-brand"].map((queryClass) => [queryClass, {
+          runs: sweeps.map((sweep) => sweep.id),
+          mentioned: series(facts, queryClass, "mentioned"),
+          byProvider: Object.fromEntries(engines.map((provider) => [provider, series(facts, queryClass, "mentioned", provider)]))
+        }]))
+      }, 1180, `Totals hide engine swings here, so reading each engine across all ${sweeps.length} sweeps.`)
+    ],
+    answer
+  };
+}
+function harborGaps(facts) {
+  const { project, latest } = facts;
+  const engines = enginesOf(latest);
+  const groups = [...byQuery(latest.answers).values()];
+  const unnamed = groups.filter((answers) => answers.every((answer2) => !answer2.mentioned));
+  const namedCounts = groups.map((answers) => answers.filter((answer2) => answer2.mentioned).length);
+  const uniformCount = namedCounts.every((count) => count === namedCounts[0]) ? namedCounts[0] : null;
+  const cell = (market, queryClass) => {
+    const answers = ofClass(latest, queryClass).filter((answer2) => marketOf(facts, answer2) === market);
+    const queries2 = queryIdsOf(answers).length;
+    const missing2 = answers.filter((answer2) => !answer2.mentioned);
+    const byEngine = engines.map((provider) => ({ provider, answers: missing2.filter((answer2) => answer2.provider === provider) })).filter((entry) => entry.answers.length > 0);
+    const rivals = unique(missing2.flatMap((answer2) => answer2.named));
+    if (missing2.length === 0) return "none";
+    const rivalText = rivals.length > 0 ? listJoin(rivals) : "no tracked competitor";
+    if (byEngine.length === 1) return `${engineName(byEngine[0].provider)}: ${rivalText} on ${byEngine[0].answers.length === queries2 ? `all ${queries2}` : `${byEngine[0].answers.length} of ${queries2}`}`;
+    return `${listJoin(byEngine.map((entry) => engineName(entry.provider)))}: ${rivalText} on ${byEngine.map((entry) => entry.answers.length).every((count) => count === byEngine[0].answers.length) ? `${byEngine[0].answers.length} each` : byEngine.map((entry) => `${entry.answers.length} (${engineName(entry.provider)})`).join(", ")}`;
+  };
+  const marketList = markets(facts);
+  const rows = marketList.map((market) => `| ${market} | ${cell(market, "non-brand")} | ${cell(market, "branded")} |`);
+  const topics = unique(ofClass(latest, "non-brand").map((answer2) => answer2.query.match(/\bfor (.+)$/)?.[1]).filter((topic) => Boolean(topic)));
+  const nonBrandMissing = ofClass(latest, "non-brand").filter((answer2) => !answer2.mentioned);
+  const nonBrandEngines = unique(nonBrandMissing.map((answer2) => answer2.provider));
+  const nonBrandRivals = unique(nonBrandMissing.flatMap((answer2) => answer2.named));
+  const brandedMissing = ofClass(latest, "branded").filter((answer2) => !answer2.mentioned);
+  const brandedPattern = unique(brandedMissing.map((answer2) => answer2.provider)).sort(engineOrder).map((provider) => {
+    const perMarket = marketList.map((market) => brandedMissing.filter((answer2) => answer2.provider === provider && marketOf(facts, answer2) === market && answer2.targetKey).map((answer2) => shortPropertyLabel(facts.properties.get(answer2.targetKey))).sort().join("|"));
+    return perMarket.every((value) => value === perMarket[0]) && perMarket[0] ? `by ${engineName(provider)} on ${listJoin(perMarket[0].split("|"))}` : null;
+  });
+  const brandedRivals = unique(brandedMissing.flatMap((answer2) => answer2.named));
+  const sentences = [];
+  if (nonBrandMissing.length > 0 && nonBrandEngines.length === 1 && topics.length > 0) {
+    sentences.push(`Non-brand covers ${listJoin(topics)} in each market. ${engineName(nonBrandEngines[0])} names ${listJoin(nonBrandRivals)} instead of Harbor on all of them, ${nonBrandMissing.length} in total.`);
+  }
+  if (brandedMissing.length > 0 && brandedPattern.every(Boolean)) {
+    sentences.push(`On branded "reviews" queries, ${listJoin(brandedRivals)} ${brandedRivals.length === 1 ? "is" : "are"} named instead ${brandedPattern.join(", and ")}, in every market: ${brandedMissing.length} in total.`);
+  }
+  const answer = [
+    unnamed.length === 0 ? `**No tracked query goes unnamed by every engine on ${formatPreviewDay(latest.createdAt)}.**${uniformCount !== null ? ` All ${groups.length} are named by ${uniformCount} of ${engines.length} engines.` : ""} The misses repeat the same way in every market:` : `**${unnamed.length} of ${groups.length} tracked queries are named by no engine on ${formatPreviewDay(latest.createdAt)}.** By market:`,
+    ['| Market | Non-brand, named instead | Branded "reviews", named instead |', "|---|---|---|", ...rows].join("\n"),
+    ...sentences,
+    `Next: start with ${nonBrandEngines.length === 1 ? `${engineName(nonBrandEngines[0])} non-brand, since it covers every market; read one answer per market to see what ${listJoin(nonBrandRivals)} ${nonBrandRivals.length === 1 ? "is" : "are"} recommended for` : "the non-brand misses"}. ${link("Open portfolio", `/projects/${project.name}/portfolio`)}`
+  ].join("\n\n");
+  const missing = latest.answers.filter((answer2) => !answer2.mentioned);
+  const rollup = unique(missing.map((answer2) => `${answer2.provider}\0${answer2.queryClass}\0${answer2.named.join(",")}`)).map((key) => {
+    const [provider, queryClass, named] = key.split("\0");
+    const matching = missing.filter((answer2) => answer2.provider === provider && answer2.queryClass === queryClass && answer2.named.join(",") === named);
+    return { provider, queryClass, namedInstead: named ? named.split(",") : [], answers: matching.length, markets: unique(matching.map((answer2) => marketOf(facts, answer2))).length };
+  }).sort((left, right) => engineOrder(left.provider, right.provider));
+  return {
+    id: "gaps",
+    steps: [
+      step("canonry_visibility_report", { project: project.name, queryClass: "all" }, {
+        selection: { queryClass: "all", run: { id: latest.id } },
+        queries: { total: groups.length, namedByNoEngine: unnamed.length, namedByEngines: uniformCount !== null ? { [`${uniformCount}/${engines.length}`]: groups.length } : namedCounts }
+      }, 1020, "Looking for queries no engine names Harbor on."),
+      step("canonry_run_get", { runId: latest.id }, { id: latest.id, status: "completed", answersWithoutHarbor: missing.length, byEngine: rollup }, 760, "None, so reading who gets named on the answers that leave Harbor out.")
+    ],
+    answer
+  };
+}
+function harborInsights(db, facts, deadLinks) {
+  const { project, latest, sweeps } = facts;
+  const active = db.select().from(insights).where(and(eq(insights.projectId, project.id), eq(insights.dismissed, false))).all();
+  const sweepIds = new Set(sweeps.map((sweep) => sweep.id));
+  const fromSweeps = active.filter((row) => row.runId !== null && sweepIds.has(row.runId));
+  const engines = enginesOf(latest);
+  const perEngine = engines.map((provider) => ({ provider, history: series(facts, "non-brand", "mentioned", provider), total: tally(ofClass(latest, "non-brand", provider)).total }));
+  const dropped = perEngine.find((entry) => entry.history.at(-1) === 0);
+  const droppedRival = dropped ? namedInstead(ofClass(latest, "non-brand", dropped.provider))[0]?.label : void 0;
+  const others = perEngine.filter((entry) => entry !== dropped);
+  const othersSwing = others.filter((entry) => Math.min(...entry.history) !== Math.max(...entry.history));
+  const totals = series(facts, "non-brand", "mentioned");
+  const totalDenominator = tally(ofClass(latest, "non-brand")).total;
+  const findings = [];
+  if (dropped) {
+    const prior = dropped.history.slice(0, -1);
+    findings.push(`**${engineName(dropped.provider)} stopped naming Harbor on non-brand.** It named Harbor on 0 of ${dropped.total} non-brand queries on ${formatPreviewDay(latest.createdAt)}${droppedRival ? ` and named ${droppedRival} on all ${dropped.total}` : ""}. Its previous low in ${sweeps.length} sweeps was ${Math.min(...prior)} of ${dropped.total}. Action: confirm on the next sweep, then compare the ${droppedRival ?? "competitor"} pages it cites with your market pages.`);
+    findings.push(`**The engines swing every sweep.** ${engineName(dropped.provider)}'s non-brand series is ${dropped.history.join(", ")}${othersSwing.length > 0 ? `, and ${listJoin(othersSwing.map((entry) => engineName(entry.provider)))} move between ${Math.min(...othersSwing.flatMap((entry) => entry.history))} and ${Math.max(...othersSwing.flatMap((entry) => entry.history))} of ${othersSwing[0].total}` : ""}. Action: judge each week on the ${engines.length}-engine total, ${totals.at(-1) === totals.at(-2) ? `${totals.at(-1)} of ${totalDenominator} on both of the last two sweeps` : `${totals.at(-1)} of ${totalDenominator} now against ${totals.at(-2)} before`}, not on one engine's week.`);
+  }
+  if (deadLinks) {
+    const detail = deadLinkDetail(deadLinks);
+    findings.push(`**${deadLinks.found} dead links from the site audit.** There is ${detail}. Action: remove or redirect that link on all ${deadLinks.sources.length} pages. ${link("Open Site Health", `/projects/${project.name}/technical-aeo`)}`);
+  }
+  const answer = [
+    `Only ${active.length} ${active.length === 1 ? "insight is" : "insights are"} stored for ${project.displayName}${fromSweeps.length === 0 ? `, and ${active.length === 2 ? "neither" : "none"} comes from a sweep` : ""}, so there is no severity ranking worth walking through. These are the ${findings.length} most important measured findings instead:`,
+    findings.map((finding, index) => `${index + 1}. ${finding}`).join("\n"),
+    `Next: ${deadLinks ? "fix the dead links now, since they need no sweep to confirm, and " : ""}${dropped ? `recheck ${engineName(dropped.provider)} non-brand after the next sweep` : "keep the weekly sweep running"}.`
+  ].join("\n\n");
+  const steps = [
+    step("canonry_insights_list", { project: project.name }, { active: active.length, fromSweeps: fromSweeps.length, fromLatestSweep: fromSweeps.filter((row) => row.runId === latest.id).length }, 430, "Listing active insights."),
+    step("canonry_visibility_report", { project: project.name, queryClass: "non-brand" }, {
+      selection: { queryClass: "non-brand", run: { id: latest.id } },
+      summary: summary(ofClass(latest, "non-brand")),
+      trend: { runs: sweeps.map((sweep) => sweep.id), byProvider: Object.fromEntries(perEngine.map((entry) => [entry.provider, entry.history])) },
+      ...dropped && droppedRival ? { namedInstead: { [dropped.provider]: { [droppedRival]: ofClass(latest, "non-brand", dropped.provider).filter((answer2) => answer2.named.includes(droppedRival)).length } } } : {}
+    }, 1090, "Too few stored insights to rank, so reading the measured non-brand picture instead.")
+  ];
+  if (deadLinks) steps.push(deadLinkStep(project, deadLinks, "And the latest site audit."));
+  return { id: "insights", steps, answer };
+}
+function buildDemoAeroPreviews(db, context) {
+  const seededAt = context.now.toISOString();
+  const previews = /* @__PURE__ */ new Map();
+  const summit = loadFacts(db, context.simple);
+  previews.set(context.simple.name, aeroPreviewResponseSchema.parse({
+    project: context.simple.name,
+    seededAt,
+    starters: [summitStatus(summit), summitChanges(summit), summitGaps(summit), summitInsights(db, summit)]
+  }));
+  const harbor = loadFacts(db, context.portfolio);
+  const deadLinks = loadDeadLinks(db, harbor);
+  previews.set(context.portfolio.name, aeroPreviewResponseSchema.parse({
+    project: context.portfolio.name,
+    seededAt,
+    starters: [harborStatus(harbor, deadLinks), harborChanges(harbor), harborGaps(harbor), harborInsights(db, harbor, deadLinks)]
+  }));
+  return previews;
+}
+
 // src/demo/http.ts
 import { createHash, randomUUID } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
-import { desc, eq } from "drizzle-orm";
+import { desc as desc2, eq as eq2 } from "drizzle-orm";
 import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import rateLimit from "@fastify/rate-limit";
@@ -139,6 +1130,8 @@ var DEMO_READ_ROUTES = /* @__PURE__ */ new Set([
   "/api/v1/projects/:name/ads/operations/:operationKey",
   "/api/v1/projects/:name/ads/status",
   "/api/v1/projects/:name/ads/summary",
+  // Scripted Aero preview built from seeded rows; the live agent routes stay closed.
+  "/api/v1/projects/:name/agent/preview",
   "/api/v1/projects/:name/analytics/competitors",
   "/api/v1/projects/:name/analytics/gaps",
   "/api/v1/projects/:name/analytics/metrics",
@@ -375,9 +1368,9 @@ async function createDemoHttpServer(options) {
       reply.header("Cache-Control", "no-store");
       if (route === "/api/v1/projects/:name/bing/coverage") {
         const name = request.params.name;
-        const project = db.select().from(projects).where(eq(projects.name, name)).get();
+        const project = db.select().from(projects).where(eq2(projects.name, name)).get();
         if (!project) return reply.code(404).send({ error: { code: "NOT_FOUND", message: "Project not found." } });
-        const rows = db.select().from(bingUrlInspections).where(eq(bingUrlInspections.projectId, project.id)).orderBy(desc(bingUrlInspections.inspectedAt)).all();
+        const rows = db.select().from(bingUrlInspections).where(eq2(bingUrlInspections.projectId, project.id)).orderBy(desc2(bingUrlInspections.inspectedAt)).all();
         const latest = /* @__PURE__ */ new Map();
         for (const row of rows) if (!latest.has(row.url)) latest.set(row.url, row);
         const format = (row) => ({ url: row.url, httpCode: row.httpCode, inIndex: row.inIndex, lastCrawledDate: row.lastCrawledDate, inIndexDate: row.inIndexDate, inspectedAt: row.inspectedAt, documentSize: row.documentSize, anchorCount: row.anchorCount, discoveryDate: row.discoveryDate });
@@ -389,9 +1382,9 @@ async function createDemoHttpServer(options) {
       }
       if (route === "/api/v1/projects/:name/bing/performance") {
         const name = request.params.name;
-        const project = db.select().from(projects).where(eq(projects.name, name)).get();
+        const project = db.select().from(projects).where(eq2(projects.name, name)).get();
         if (!project) return reply.code(404).send({ error: { code: "NOT_FOUND", message: "Project not found." } });
-        return reply.send(db.select().from(bingKeywordStats).where(eq(bingKeywordStats.projectId, project.id)).limit(200).all().map((row) => ({
+        return reply.send(db.select().from(bingKeywordStats).where(eq2(bingKeywordStats.projectId, project.id)).limit(200).all().map((row) => ({
           query: row.query,
           impressions: row.impressions,
           clicks: row.clicks,
@@ -411,6 +1404,12 @@ async function createDemoHttpServer(options) {
   app.get("/health", async () => ({ status: "ok", service: "canonry-demo", version: PACKAGE_VERSION, demo: true, workerEnabled: false }));
   app.get("/api/v1/session", async () => ({ authenticated: true, setupRequired: false }));
   app.get("/api/v1/demo", async () => ({ mode: "view-only", sampleData: true, seededAt: now.toISOString() }));
+  const aeroPreviews = options.aeroPreviews ?? /* @__PURE__ */ new Map();
+  app.get("/api/v1/projects/:name/agent/preview", async (request, reply) => {
+    const preview = aeroPreviews.get(request.params.name);
+    if (!preview) return reply.code(404).send({ error: { code: "NOT_FOUND", message: "Project not found." } });
+    return reply.send(preview);
+  });
   await app.register(apiRoutes, { db, skipAuth: true, ...options.readOptions });
   await app.register(fastifyStatic, {
     root: join(assetsDir, "assets"),
@@ -646,7 +1645,7 @@ function seedProjectMarketing(db, project, now) {
 }
 
 // src/demo/seed-exploration.ts
-import { and, eq as eq2 } from "drizzle-orm";
+import { and as and2, eq as eq3 } from "drizzle-orm";
 function seedDemoExploration(db, context) {
   const createdAt = context.now.toISOString();
   for (const project of [context.simple, context.portfolio]) {
@@ -674,7 +1673,7 @@ function seedDemoExploration(db, context) {
   }
 }
 function seedPageAudits(db, projectId, runId, root, createdAt) {
-  const crawlPages = db.select().from(siteCrawlPages).where(and(eq2(siteCrawlPages.projectId, projectId), eq2(siteCrawlPages.runId, runId))).all();
+  const crawlPages = db.select().from(siteCrawlPages).where(and2(eq3(siteCrawlPages.projectId, projectId), eq3(siteCrawlPages.runId, runId))).all();
   const audited = crawlPages.filter((page) => page.auditState === "success" && page.auditScore !== null);
   const pages = audited.map((page, index) => {
     const factors2 = siteAuditPageFactorSchema.array().parse(page.auditFields.factors);
@@ -744,10 +1743,10 @@ function harborProperties() {
 }
 
 // src/demo/seed-answer-intelligence.ts
-import { and as and2, asc, eq as eq3 } from "drizzle-orm";
+import { and as and3, asc as asc2, eq as eq4 } from "drizzle-orm";
 function seedDemoAnswerIntelligence(db, project) {
   const service2 = new IntelligenceService(db);
-  const sweeps = db.select().from(runs).where(and2(eq3(runs.projectId, project.id), eq3(runs.kind, RunKinds["answer-visibility"]))).orderBy(asc(runs.createdAt)).all();
+  const sweeps = db.select().from(runs).where(and3(eq4(runs.projectId, project.id), eq4(runs.kind, RunKinds["answer-visibility"]))).orderBy(asc2(runs.createdAt)).all();
   for (const [index, sweep] of sweeps.entries()) {
     const previous = index > 0 ? sweeps[index - 1] : null;
     const history = sweeps.slice(Math.max(0, index - (HISTORY_WINDOW_RUNS - 1)), index + 1);
@@ -787,123 +1786,6 @@ function seedDemoAnswerIntelligence(db, project) {
   }
 }
 
-// src/demo/summit-sweeps.ts
-var SUMMIT_SWEEP_COUNT = 6;
-var SUMMIT_ENGINES = ["openai", "gemini", "claude"];
-var RIVALS = {
-  roofcraft: { name: "RoofCraft", domain: "roofcraft.example", path: "/roof-replacement/", blurb: "A replacement contractor known for metal and shingle installs." },
-  everlast: { name: "Everlast Roofing", domain: "everlast-roofing.example", path: "/services/", blurb: "A repair and gutter company with a large emergency crew." }
-};
-var SUMMIT_COMPETITORS = Object.values(RIVALS).map((rival) => ({ domain: rival.domain, label: rival.name }));
-var SUMMIT_QUERIES = [
-  { key: "reviews", text: "Summit Roofing reviews", pages: ["/reviews/"], rivals: [], source: "https://home-services-reviews.example/roofers/", lead: "Recent homeowner reviews are mostly positive.", blurb: "Reviewers mention clear estimates, tidy crews and quick follow-up on warranty visits." },
-  { key: "near-me", text: "roof repair contractor near me", pages: ["/services/roof-repair/", "/service-areas/"], rivals: ["everlast", "roofcraft"], source: "https://local-contractor-directory.example/roofing/", lead: "Several roofers in the area handle repair work.", blurb: "A local roofer covering leak repairs, storm damage and inspections across two dozen towns." },
-  { key: "emergency-leak", text: "emergency roof leak repair", pages: ["/services/roof-repair/leak-repair/", "/services/roof-repair/emergency-tarping/"], rivals: ["everlast"], source: "https://homeowner-guides.example/roof-leaks/", lead: "For an active leak, look for a crew that can tarp the roof the same day.", blurb: "Offers emergency tarping and leak repair, with same-day visits in its service area." },
-  { key: "metal-installer", text: "best metal roof installer", pages: ["/services/roof-replacement/metal-roofing/", "/guides/metal-vs-asphalt-shingles/"], rivals: ["roofcraft"], source: "https://metal-roofing-council.example/find-an-installer/", lead: "Metal roofs need an installer with standing-seam experience.", blurb: "Installs standing-seam and metal shingle roofs and publishes a metal versus asphalt comparison." },
-  { key: "warranty", text: "Summit Roofing warranty", pages: ["/about/warranty/"], rivals: [], source: "https://homeowner-guides.example/roof-warranties/", lead: "Roofing warranties usually combine manufacturer and workmanship coverage.", blurb: "Backs replacements with a written workmanship warranty on top of the manufacturer coverage." },
-  { key: "replacement-cost", text: "how much does a roof replacement cost", pages: ["/guides/how-much-does-a-roof-replacement-cost/", "/financing/"], rivals: ["roofcraft"], source: "https://home-cost-report.example/roof-replacement/", lead: "Most full replacements land between 9,000 and 18,000 dollars, depending on size and material.", blurb: "Publishes a cost guide with typical price ranges and offers financing on full replacements." },
-  { key: "storm-claims", text: "storm damage roof repair and insurance claims", pages: ["/services/roof-repair/storm-damage/", "/guides/filing-a-roof-insurance-claim/"], rivals: ["everlast"], source: "https://homeowner-guides.example/storm-claims/", lead: "Photograph the damage before any repair and call your insurer early.", blurb: "Documents storm damage for insurance claims and joins the adjuster visit." },
-  { key: "asphalt-shingles", text: "asphalt shingle roof replacement", pages: ["/services/roof-replacement/asphalt-shingles/"], rivals: ["roofcraft"], source: "https://home-cost-report.example/asphalt-shingles/", lead: "Architectural shingles are the most common replacement choice.", blurb: "Replaces asphalt shingle roofs with a choice of architectural shingle lines." },
-  { key: "seamless-gutters", text: "seamless gutter installation", pages: ["/services/gutters/seamless-gutters/"], rivals: ["everlast"], source: "https://homeowner-guides.example/gutters/", lead: "Seamless gutters are formed on site, so they leak less at the joints.", blurb: "Installs seamless gutters and gutter guards, often alongside a roof replacement." },
-  { key: "pre-purchase-inspection", text: "roof inspection before buying a house", pages: ["/services/roof-inspection/real-estate-inspection/", "/guides/real-estate-roof-inspections/"], rivals: ["roofcraft", "everlast"], source: "https://home-buyer-checklist.example/roof-inspection/", lead: "A roof inspection before closing can surface repairs to negotiate.", blurb: "Runs pre-purchase roof inspections with photo reports for buyers and agents." }
-];
-var SUMMIT_BRANDED_QUERY_KEYS = ["reviews", "warranty"];
-var SUMMIT_ENGINE_PLANS = {
-  // Climbs steadily.
-  openai: {
-    mentioned: [2, 3, 3, 4, 5, 6],
-    mentionOrder: ["emergency-leak", "replacement-cost", "near-me", "storm-claims", "pre-purchase-inspection", "seamless-gutters", "asphalt-shingles", "metal-installer"],
-    cited: [1, 2, 2, 3, 4, 5],
-    citationOrder: ["replacement-cost", "storm-claims", "pre-purchase-inspection", "emergency-leak", "asphalt-shingles", "metal-installer", "seamless-gutters", "near-me"]
-  },
-  // Steady, then a dip and a recovery.
-  gemini: {
-    mentioned: [4, 4, 4, 2, 3, 5],
-    mentionOrder: ["near-me", "emergency-leak", "replacement-cost", "storm-claims", "seamless-gutters", "pre-purchase-inspection", "metal-installer", "asphalt-shingles"],
-    cited: [3, 3, 3, 1, 2, 3],
-    citationOrder: ["replacement-cost", "pre-purchase-inspection", "storm-claims", "metal-installer", "emergency-leak", "asphalt-shingles", "seamless-gutters", "near-me"]
-  },
-  // Swings from week to week.
-  claude: {
-    mentioned: [3, 1, 4, 2, 4, 3],
-    mentionOrder: ["emergency-leak", "replacement-cost", "storm-claims", "near-me", "pre-purchase-inspection", "asphalt-shingles", "seamless-gutters", "metal-installer"],
-    cited: [2, 1, 2, 1, 3, 2],
-    citationOrder: ["pre-purchase-inspection", "replacement-cost", "storm-claims", "emergency-leak", "asphalt-shingles", "near-me", "metal-installer", "seamless-gutters"]
-  }
-};
-var BRANDED_PLAN = {
-  reviews: {
-    openai: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
-    gemini: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
-    claude: { mentioned: [true, true, true, true, true, true], cited: [false, false, false, false, false, false] }
-  },
-  warranty: {
-    openai: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
-    gemini: { mentioned: [true, true, true, false, true, true], cited: [true, true, true, false, true, true] },
-    claude: { mentioned: [true, true, true, true, true, true], cited: [false, false, true, false, true, true] }
-  }
-};
-function isBranded(key) {
-  return SUMMIT_BRANDED_QUERY_KEYS.includes(key);
-}
-function summitAnswerPlan(sweep, engine, queryKey) {
-  if (isBranded(queryKey)) {
-    const plan2 = BRANDED_PLAN[queryKey][engine];
-    return { mentioned: plan2.mentioned[sweep], cited: plan2.cited[sweep] };
-  }
-  const plan = SUMMIT_ENGINE_PLANS[engine];
-  return {
-    mentioned: plan.mentionOrder.slice(0, plan.mentioned[sweep]).includes(queryKey),
-    cited: plan.citationOrder.slice(0, plan.cited[sweep]).includes(queryKey)
-  };
-}
-function summitAnswer(input) {
-  const { sweep, engine, queryIndex, displayName, domain } = input;
-  const query = SUMMIT_QUERIES[queryIndex];
-  const engineIndex = SUMMIT_ENGINES.indexOf(engine);
-  const plan = summitAnswerPlan(sweep, engine, query.key);
-  const rivals = plan.mentioned ? (sweep + engineIndex + queryIndex) % 2 === 0 ? query.rivals.slice(0, 1) : [] : query.rivals;
-  const entries = [
-    ...plan.mentioned ? [{ name: displayName, blurb: query.blurb }] : [],
-    ...rivals.map((key) => ({ name: RIVALS[key].name, blurb: RIVALS[key].blurb }))
-  ];
-  const answerText = isBranded(query.key) && !plan.mentioned ? `Fictional answer.
-
-I could not find published details for that company. ${query.lead} Most residential roofers offer 5 to 10 years of workmanship coverage.` : [
-    "Fictional answer.",
-    query.lead,
-    entries.map((entry, index) => `${index + 1}. **${entry.name}**: ${entry.blurb}`).join("\n"),
-    "Get two or three written estimates before you commit."
-  ].join("\n\n");
-  const citedRivals = rivals.filter((_, index) => (sweep + engineIndex + queryIndex + index) % 3 !== 0);
-  const citedUrls = [
-    ...plan.cited ? [`https://${domain}${query.pages[(sweep + engineIndex) % query.pages.length]}`] : [],
-    ...citedRivals.map((key) => `https://${RIVALS[key].domain}${RIVALS[key].path}`),
-    query.source
-  ];
-  const citedDomains = citedUrls.map((url) => new URL(url).hostname);
-  const normalized = {
-    provider: engine,
-    answerText,
-    citedDomains,
-    groundingSources: citedUrls.map((uri) => ({ uri, title: "" })),
-    searchQueries: [query.text],
-    retrievalStatus: "used"
-  };
-  const domains = effectiveDomains({ canonicalDomain: domain, ownedDomains: [domain] });
-  const brandNames = effectiveBrandNames({ displayName, canonicalDomain: domain, ownedDomains: [domain] });
-  const competitorDomains = SUMMIT_COMPETITORS.map((competitor) => competitor.domain);
-  return {
-    answerText,
-    answerMentioned: determineAnswerMentioned(answerText, brandNames, domains),
-    citationState: determineCitationState(normalized, domains),
-    citedDomains,
-    citedUrls,
-    competitorOverlap: computeCompetitorOverlap(normalized, competitorDomains),
-    recommendedCompetitors: extractRecommendedCompetitors(answerText, domains, citedDomains, competitorDomains, brandNames)
-  };
-}
-
 // src/demo/seed-core.ts
 var PROVIDERS = [
   { provider: "openai", requestedModel: "gpt-5-demo", servedModel: "gpt-5-demo-2026-08-15" },
@@ -1731,7 +2613,7 @@ var guide = (slug) => `/guides/${slug}/`;
 function summitRoofingInventory() {
   const pages = [];
   const links = [];
-  const link = (source, ...targets) => {
+  const link2 = (source, ...targets) => {
     for (const target of targets) links.push([source, target]);
   };
   const projects2 = Array.from({ length: 36 }, (_, index) => {
@@ -1744,7 +2626,7 @@ function summitRoofingInventory() {
     { path: "/llms.txt", kind: "resource", contentType: "text/plain; charset=utf-8", sitemap: true },
     { path: "/services/", kind: "html", score: 84 }
   );
-  link(
+  link2(
     "/",
     ...SERVICES.map(([key]) => service(key)),
     "/service-areas/",
@@ -1756,12 +2638,12 @@ function summitRoofingInventory() {
     "/financing/",
     "/get-a-quote/"
   );
-  link("/services/", ...SERVICES.map(([key]) => service(key)), "/service-areas/");
+  link2("/services/", ...SERVICES.map(([key]) => service(key)), "/service-areas/");
   for (const [categoryIndex, [category, subs]] of SERVICES.entries()) {
     pages.push({ path: service(category), kind: "html", score: 86 - categoryIndex * 2 });
     const categoryGuides = GUIDES.filter(([, key]) => key === category);
     const categoryProjects = projects2.filter((project) => project.category === category);
-    link(
+    link2(
       service(category),
       ...subs.map((sub) => service(`${category}/${sub}`)),
       "/get-a-quote/",
@@ -1773,17 +2655,17 @@ function summitRoofingInventory() {
       const path = service(`${category}/${sub}`);
       pages.push({ path, kind: "html", score: 83 - (subIndex * 7 + categoryIndex * 3) % 17 });
       const project = categoryProjects.find((candidate) => candidate.sub === sub) ?? categoryProjects.at(0);
-      link(path, service(category), service(`${category}/${subs[(subIndex + 1) % subs.length]}`), "/get-a-quote/");
-      if (project) link(path, project.path);
+      link2(path, service(category), service(`${category}/${subs[(subIndex + 1) % subs.length]}`), "/get-a-quote/");
+      if (project) link2(path, project.path);
       const related = categoryGuides.at(subIndex % Math.max(1, categoryGuides.length));
-      if (related) link(path, guide(related[0]));
+      if (related) link2(path, guide(related[0]));
     }
   }
   pages.push({ path: "/service-areas/", kind: "html", score: 78 });
-  link("/service-areas/", ...TOWNS.map(town));
+  link2("/service-areas/", ...TOWNS.map(town));
   for (const [townIndex, townKey] of TOWNS.entries()) {
     pages.push({ path: town(townKey), kind: "html", score: 76 - townIndex % 6 * 2, factorScores: { "geographic-signals": 92 } });
-    link(
+    link2(
       town(townKey),
       service("roof-replacement"),
       service("roof-repair"),
@@ -1799,16 +2681,16 @@ function summitRoofingInventory() {
       const path = `${town(townKey)}${serviceKey}/`;
       const thin = THIN_TOWN_SERVICES.has(path);
       pages.push({ path, kind: "html", score: thin ? 58 : 72, factorScores: thin ? { "content-depth": 34, "geographic-signals": 88 } : { "geographic-signals": 94 } });
-      link(path, town(townKey), service(serviceKey), "/get-a-quote/");
-      if (path !== ORPHAN_TOWN_SERVICE) link(town(townKey), path);
+      link2(path, town(townKey), service(serviceKey), "/get-a-quote/");
+      if (path !== ORPHAN_TOWN_SERVICE) link2(town(townKey), path);
     }
   }
   pages.push({ path: "/projects/", kind: "html", score: 80 });
-  link("/projects/", ...projects2.map((project) => project.path));
+  link2("/projects/", ...projects2.map((project) => project.path));
   for (const project of projects2) {
     const thin = THIN_PROJECTS.has(project.index);
     pages.push({ path: project.path, kind: "html", score: thin ? 60 : 77 - project.index % 7 * 2, factorScores: thin ? { "content-depth": 31 } : void 0 });
-    link(
+    link2(
       project.path,
       service(project.category),
       service(`${project.category}/${project.sub}`),
@@ -1825,21 +2707,21 @@ function summitRoofingInventory() {
     { path: "/guides/topic/", kind: "noindex", score: 70 },
     { path: "/guides/roof-maintenance-checklist.pdf", kind: "resource", contentType: "application/pdf" }
   );
-  link("/guides/", ...GUIDES.slice(0, 20).map(([slug]) => guide(slug)), "/guides/page/2/", "/guides/topic/");
-  link("/guides/page/2/", ...GUIDES.slice(20, 40).map(([slug]) => guide(slug)), "/guides/", "/guides/page/3/");
-  link("/guides/page/3/", ...GUIDES.slice(40).map(([slug]) => guide(slug)), "/guides/page/2/");
-  link("/guides/topic/", ...GUIDE_TOPICS2.map((topic) => `/guides/topic/${topic}/`));
+  link2("/guides/", ...GUIDES.slice(0, 20).map(([slug]) => guide(slug)), "/guides/page/2/", "/guides/topic/");
+  link2("/guides/page/2/", ...GUIDES.slice(20, 40).map(([slug]) => guide(slug)), "/guides/", "/guides/page/3/");
+  link2("/guides/page/3/", ...GUIDES.slice(40).map(([slug]) => guide(slug)), "/guides/page/2/");
+  link2("/guides/topic/", ...GUIDE_TOPICS2.map((topic) => `/guides/topic/${topic}/`));
   for (const topic of GUIDE_TOPICS2) {
     pages.push({ path: `/guides/topic/${topic}/`, kind: "noindex", score: 68 });
-    link(`/guides/topic/${topic}/`, "/guides/", ...GUIDES.filter(([, , guideTopic]) => guideTopic === topic).map(([slug]) => guide(slug)));
+    link2(`/guides/topic/${topic}/`, "/guides/", ...GUIDES.filter(([, , guideTopic]) => guideTopic === topic).map(([slug]) => guide(slug)));
   }
   for (const [guideIndex, [slug, serviceKey, topic]] of GUIDES.entries()) {
     const noAuthor = guideIndex % 5 === 4;
     pages.push({ path: guide(slug), kind: "html", score: 81 - guideIndex % 6 * 3, factorScores: noAuthor ? { "eeat-signals": 28 } : void 0 });
-    link(guide(slug), service(serviceKey), guide(GUIDES[(guideIndex + 1) % GUIDES.length][0]), `/guides/topic/${topic}/`, "/get-a-quote/");
+    link2(guide(slug), service(serviceKey), guide(GUIDES[(guideIndex + 1) % GUIDES.length][0]), `/guides/topic/${topic}/`, "/get-a-quote/");
   }
-  link(guide(GUIDES[18][0]), "/guides/roof-maintenance-checklist.pdf");
-  link(guide("what-a-roof-warranty-covers"), "/about/warranty/");
+  link2(guide(GUIDES[18][0]), "/guides/roof-maintenance-checklist.pdf");
+  link2(guide("what-a-roof-warranty-covers"), "/about/warranty/");
   pages.push(
     { path: "/financing/", kind: "html", score: 79 },
     { path: "/financing/apply/", kind: "html", score: 71 },
@@ -1867,19 +2749,19 @@ function summitRoofingInventory() {
     { path: "/terms/", kind: "html", score: 63 },
     { path: "/accessibility/", kind: "html", score: 69 }
   );
-  link("/financing/", "/financing/apply/", "/financing/faq/", "/financing/financing-terms.pdf", "/get-a-quote/");
-  link("/financing/faq/", "/financing/apply/");
-  link("/reviews/", "/reviews/leave-a-review/", ...projects2.slice(0, 6).map((project) => project.path));
-  link("/about/", "/about/team/", "/about/certifications/", "/about/warranty/", "/about/community/", "/reviews/");
-  link("/about/warranty/", "/about/warranty/warranty-guide.pdf", guide("what-a-roof-warranty-covers"));
-  link("/about/certifications/", service("roof-replacement"));
-  link("/about/community/", "/projects/");
-  link("/careers/", "/careers/roofing-crew-lead/", "/careers/project-manager/", "/careers/sales-estimator/");
-  for (const role of ["roofing-crew-lead", "project-manager", "sales-estimator"]) link(`/careers/${role}/`, "/careers/");
-  link("/contact/", "/contact/thank-you/");
-  link("/get-a-quote/", "/get-a-quote/roof-details/", "/financing/");
-  link("/get-a-quote/roof-details/", "/get-a-quote/schedule/");
-  link("/get-a-quote/schedule/", "/get-a-quote/thank-you/");
+  link2("/financing/", "/financing/apply/", "/financing/faq/", "/financing/financing-terms.pdf", "/get-a-quote/");
+  link2("/financing/faq/", "/financing/apply/");
+  link2("/reviews/", "/reviews/leave-a-review/", ...projects2.slice(0, 6).map((project) => project.path));
+  link2("/about/", "/about/team/", "/about/certifications/", "/about/warranty/", "/about/community/", "/reviews/");
+  link2("/about/warranty/", "/about/warranty/warranty-guide.pdf", guide("what-a-roof-warranty-covers"));
+  link2("/about/certifications/", service("roof-replacement"));
+  link2("/about/community/", "/projects/");
+  link2("/careers/", "/careers/roofing-crew-lead/", "/careers/project-manager/", "/careers/sales-estimator/");
+  for (const role of ["roofing-crew-lead", "project-manager", "sales-estimator"]) link2(`/careers/${role}/`, "/careers/");
+  link2("/contact/", "/contact/thank-you/");
+  link2("/get-a-quote/", "/get-a-quote/roof-details/", "/financing/");
+  link2("/get-a-quote/roof-details/", "/get-a-quote/schedule/");
+  link2("/get-a-quote/schedule/", "/get-a-quote/thank-you/");
   pages.push(
     { path: "/roof-repair/", kind: "redirect", redirectTo: service("roof-repair") },
     { path: "/blog/", kind: "redirect", redirectTo: "/guides/" },
@@ -1888,32 +2770,32 @@ function summitRoofingInventory() {
     { path: "/service-areas/old-county/", kind: "redirect", redirectTo: "/service-areas/" },
     { path: "/free-estimate/", kind: "redirect", redirectTo: "/get-a-quote/" }
   );
-  link(service("roof-repair/leak-repair"), "/roof-repair/");
-  link(guide("how-to-spot-a-roof-leak"), "/roof-repair/");
-  link(guide("signs-you-need-a-new-roof"), "/blog/");
-  link(guide("roof-repair-vs-replacement"), "/blog/");
-  link(guide("metal-vs-asphalt-shingles"), "/services/metal-roofs/");
-  link(guide("winter-roof-care"), "/guides/ice-dam-prevention-2023/");
-  link(town(TOWNS.at(-1)), "/service-areas/old-county/");
-  link(projects2[0].path, "/free-estimate/");
-  link("/financing/faq/", "/free-estimate/");
+  link2(service("roof-repair/leak-repair"), "/roof-repair/");
+  link2(guide("how-to-spot-a-roof-leak"), "/roof-repair/");
+  link2(guide("signs-you-need-a-new-roof"), "/blog/");
+  link2(guide("roof-repair-vs-replacement"), "/blog/");
+  link2(guide("metal-vs-asphalt-shingles"), "/services/metal-roofs/");
+  link2(guide("winter-roof-care"), "/guides/ice-dam-prevention-2023/");
+  link2(town(TOWNS.at(-1)), "/service-areas/old-county/");
+  link2(projects2[0].path, "/free-estimate/");
+  link2("/financing/faq/", "/free-estimate/");
   pages.push(
     { path: "/careers/estimator-2025/", kind: "broken" },
     { path: "/financing/spring-promo/", kind: "broken" },
     { path: "/guides/hail-season-update/", kind: "broken" },
     { path: `/projects/${TOWNS[2]}-reroof-draft/`, kind: "broken" }
   );
-  link("/careers/", "/careers/estimator-2025/");
-  link("/financing/", "/financing/spring-promo/");
-  link(guide("what-to-do-after-hail-damage"), "/guides/hail-season-update/");
-  link(guide("storm-season-preparation"), "/guides/hail-season-update/");
-  link("/projects/", `/projects/${TOWNS[2]}-reroof-draft/`);
+  link2("/careers/", "/careers/estimator-2025/");
+  link2("/financing/", "/financing/spring-promo/");
+  link2(guide("what-to-do-after-hail-damage"), "/guides/hail-season-update/");
+  link2(guide("storm-season-preparation"), "/guides/hail-season-update/");
+  link2("/projects/", `/projects/${TOWNS[2]}-reroof-draft/`);
   pages.push(
     { path: "/spring-roof-special/", kind: "html", score: 52, factorScores: { "content-freshness": 18 } },
     { path: "/guides/choosing-roof-color/", kind: "html", score: 74 }
   );
-  link("/spring-roof-special/", "/get-a-quote/");
-  link("/guides/choosing-roof-color/", service("roof-replacement"));
+  link2("/spring-roof-special/", "/get-a-quote/");
+  link2("/guides/choosing-roof-color/", service("roof-replacement"));
   return { pages, templateLinks: [...HEADER, ...FOOTER], links };
 }
 
@@ -2010,7 +2892,7 @@ function seedLocalAndCommercialSignals(db, input) {
 }
 
 // src/demo/stores.ts
-import { and as and3, eq as eq4 } from "drizzle-orm";
+import { and as and4, eq as eq5 } from "drizzle-orm";
 function refuseMutation() {
   throw new Error("The public demo stores are view only.");
 }
@@ -2029,9 +2911,9 @@ function demoReadOptions(db, context) {
     // allowed, and no Google client id, secret, token, or transport is wired.
     googleStateSecret: "public-demo-no-oauth-callbacks",
     googleConnectionStore: {
-      listConnections: (domain) => db.select().from(googleConnections).where(eq4(googleConnections.domain, domain)).all().map(mapGoogle),
+      listConnections: (domain) => db.select().from(googleConnections).where(eq5(googleConnections.domain, domain)).all().map(mapGoogle),
       getConnection: (domain, type) => {
-        const row = db.select().from(googleConnections).where(and3(eq4(googleConnections.domain, domain), eq4(googleConnections.connectionType, type))).get();
+        const row = db.select().from(googleConnections).where(and4(eq5(googleConnections.domain, domain), eq5(googleConnections.connectionType, type))).get();
         return row ? mapGoogle(row) : void 0;
       },
       upsertConnection: refuseMutation,
@@ -2040,7 +2922,7 @@ function demoReadOptions(db, context) {
     },
     bingConnectionStore: {
       getConnection: (domain) => {
-        const row = db.select().from(bingConnections).where(eq4(bingConnections.domain, domain)).get();
+        const row = db.select().from(bingConnections).where(eq5(bingConnections.domain, domain)).get();
         return row ? { domain, siteUrl: row.siteUrl, apiKey: "", createdAt: row.createdAt, updatedAt: row.updatedAt } : void 0;
       },
       upsertConnection: refuseMutation,
@@ -2107,12 +2989,14 @@ async function createDemoServer(options = {}) {
     await seedDemoSignals(db, context);
     seedDemoExploration(db, context);
     seedDemoMarketing(db, context);
+    const aeroPreviews = buildDemoAeroPreviews(db, context);
     const app = await createDemoHttpServer({
       db,
       now: context.now,
       trustProxy: options.trustProxy,
       assetsDir: options.assetsDir ?? join2(dirname(fileURLToPath(import.meta.url)), "..", "assets"),
-      readOptions: demoReadOptions(db, context)
+      readOptions: demoReadOptions(db, context),
+      aeroPreviews
     });
     db.$client.pragma("query_only = ON");
     app.addHook("onClose", async () => {