@ainyc/canonry 3.3.3 → 3.3.9

package/dist/cli.js

@@ -17,7 +17,7 @@ import {
   setGoogleAuthConfig,
   showFirstRunNotice,
   trackEvent
-} from "./chunk-GH5ILITH.js";
+} from "./chunk-P6D3O5JB.js";
 import {
   CcReleaseSyncStatuses,
   CheckScopes,
@@ -48,7 +48,7 @@ import {
   saveConfigPatch,
   skillsClientSchema,
   usageError
-} from "./chunk-NCGX6UI4.js";
+} from "./chunk-24C7RMIS.js";
 import {
   apiKeys,
   competitors,
@@ -71,9 +71,9 @@ import { parseArgs } from "util";
 function commandId(spec) {
   return spec.path.join(".");
 }
-function matchesPath(args, path9) {
-  if (args.length < path9.length) return false;
-  return path9.every((segment, index) => args[index] === segment);
+function matchesPath(args, path10) {
+  if (args.length < path10.length) return false;
+  return path10.every((segment, index) => args[index] === segment);
 }
 function withFormatOption(options) {
   if (!options) {
@@ -2015,9 +2015,9 @@ async function gaConnect(project, opts) {
     propertyId: opts.propertyId
   };
   if (opts.keyFile) {
-    const fs10 = await import("fs");
+    const fs11 = await import("fs");
     try {
-      const content = fs10.readFileSync(opts.keyFile, "utf-8");
+      const content = fs11.readFileSync(opts.keyFile, "utf-8");
       JSON.parse(content);
       body.keyJson = content;
     } catch (e) {
@@ -5174,6 +5174,988 @@ var PROJECT_CLI_COMMANDS = [
   }
 ];
 
+// src/commands/report.ts
+import fs4 from "fs";
+import path3 from "path";
+
+// src/report-renderer.ts
+var COLORS = {
+  bg: "#09090b",
+  surface: "#18181b4d",
+  border: "#27272a99",
+  text: "#fafafa",
+  textMuted: "#a1a1aa",
+  textFaint: "#71717a",
+  positive: "#10b981",
+  caution: "#f59e0b",
+  negative: "#f43f5e",
+  neutral: "#71717a",
+  accent: "#3b82f6",
+  series: ["#10b981", "#3b82f6", "#ec4899", "#eab308", "#a855f7", "#f97316", "#06b6d4", "#ef4444"]
+};
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function formatRatio(value) {
+  if (!Number.isFinite(value) || value === 0) return "0%";
+  return `${(value * 100).toFixed(1)}%`;
+}
+function formatNumber(value) {
+  if (!Number.isFinite(value)) return "\u2014";
+  if (Math.abs(value) >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
+  if (Math.abs(value) >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
+  return value.toLocaleString("en-US");
+}
+function summarizeQueryParams(params) {
+  const keys = Array.from(params.keys());
+  const total = keys.length;
+  if (total === 0) return "";
+  const noun = total === 1 ? "param" : "params";
+  const tag = inferAdSource(params);
+  return tag ? `${tag} \xB7 ${total} ${noun}` : `${total} tracking ${noun}`;
+}
+function inferAdSource(params) {
+  if (params.has("fbclid")) return "Facebook Ad";
+  if (params.has("gclid") || params.has("gbraid") || params.has("wbraid")) return "Google Ad";
+  if (params.has("msclkid")) return "Microsoft Ad";
+  if (params.has("ttclid")) return "TikTok Ad";
+  if (params.has("li_fat_id")) return "LinkedIn Ad";
+  if (params.has("twclid")) return "X / Twitter Ad";
+  if (params.has("epik")) return "Pinterest Ad";
+  for (const k of params.keys()) {
+    if (k.startsWith("hsa_")) return "Search Ad";
+  }
+  const src = params.get("utm_source");
+  const med = params.get("utm_medium");
+  if (src && med) return `${src} / ${med}`;
+  if (src) return `Source: ${src}`;
+  if (med) return `Medium: ${med}`;
+  return null;
+}
+function formatLandingPageHtml(raw) {
+  const value = raw ?? "";
+  const queryIdx = value.indexOf("?");
+  const path10 = queryIdx === -1 ? value : value.slice(0, queryIdx);
+  const query = queryIdx === -1 ? "" : value.slice(queryIdx + 1);
+  const pathHtml = `<span class="page-path">${escapeHtml(path10 || "/")}</span>`;
+  if (!query) return pathHtml;
+  let summary = "";
+  try {
+    summary = summarizeQueryParams(new URLSearchParams(query));
+  } catch {
+    summary = "tracking params";
+  }
+  if (!summary) return pathHtml;
+  return `${pathHtml}<span class="page-query" title="${escapeHtml(value)}">${escapeHtml(summary)}</span>`;
+}
+function formatDate(iso) {
+  if (!iso) return "\u2014";
+  try {
+    const d = new Date(iso);
+    return d.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+  } catch {
+    return iso;
+  }
+}
+function pressureTone(label) {
+  if (label === "High") return "negative";
+  if (label === "Moderate") return "caution";
+  if (label === "Low") return "positive";
+  return "neutral";
+}
+function severityTone(severity) {
+  switch (severity) {
+    case "critical":
+      return "negative";
+    case "high":
+      return "negative";
+    case "medium":
+      return "caution";
+    case "low":
+      return "neutral";
+  }
+}
+var STYLE = `
+:root {
+  color-scheme: dark;
+}
+* { box-sizing: border-box; }
+html, body { margin: 0; padding: 0; }
+body {
+  background: ${COLORS.bg};
+  color: ${COLORS.text};
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+  font-size: 14px;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
+}
+.container {
+  max-width: 1100px;
+  margin: 0 auto;
+  padding: 48px 24px 96px;
+}
+.header {
+  border-bottom: 1px solid ${COLORS.border};
+  padding-bottom: 32px;
+  margin-bottom: 48px;
+}
+.header h1 {
+  font-size: 32px;
+  font-weight: 700;
+  margin: 0 0 8px;
+  letter-spacing: -0.02em;
+}
+.header .subtitle {
+  color: ${COLORS.textMuted};
+  font-size: 14px;
+}
+.eyebrow {
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  font-size: 10px;
+  color: ${COLORS.textFaint};
+  font-weight: 600;
+  margin-bottom: 8px;
+}
+section.report-section {
+  margin: 64px 0;
+}
+section.report-section h2 {
+  font-size: 22px;
+  font-weight: 700;
+  margin: 0 0 24px;
+  letter-spacing: -0.01em;
+}
+section.report-section .section-intro {
+  color: ${COLORS.textMuted};
+  margin-bottom: 24px;
+}
+.metric-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: 16px;
+}
+.metric {
+  background: ${COLORS.surface};
+  border: 1px solid ${COLORS.border};
+  border-radius: 8px;
+  padding: 16px 20px;
+}
+.metric .label {
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  font-size: 10px;
+  color: ${COLORS.textFaint};
+  font-weight: 600;
+  margin-bottom: 8px;
+}
+.metric .value {
+  font-size: 28px;
+  font-weight: 700;
+  letter-spacing: -0.02em;
+}
+.metric .delta {
+  font-size: 12px;
+  color: ${COLORS.textMuted};
+  margin-top: 4px;
+}
+.findings {
+  margin-top: 24px;
+  display: grid;
+  gap: 12px;
+}
+.finding {
+  background: ${COLORS.surface};
+  border: 1px solid ${COLORS.border};
+  border-left-width: 3px;
+  border-radius: 6px;
+  padding: 12px 16px;
+}
+.finding.tone-positive { border-left-color: ${COLORS.positive}; }
+.finding.tone-caution { border-left-color: ${COLORS.caution}; }
+.finding.tone-negative { border-left-color: ${COLORS.negative}; }
+.finding.tone-neutral { border-left-color: ${COLORS.neutral}; }
+.finding strong { display: block; margin-bottom: 4px; }
+.finding span { color: ${COLORS.textMuted}; font-size: 13px; }
+table.report-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 13px;
+}
+table.report-table th, table.report-table td {
+  text-align: left;
+  padding: 10px 12px;
+  border-bottom: 1px solid ${COLORS.border};
+  vertical-align: top;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+}
+table.report-table th {
+  font-weight: 600;
+  color: ${COLORS.textMuted};
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  font-size: 10px;
+}
+table.report-table td.numeric { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }
+table.report-table td.page-cell { max-width: 0; }
+table.report-table td.page-cell .page-path {
+  display: block;
+  font-family: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace;
+  font-size: 12px;
+  color: ${COLORS.text};
+}
+table.report-table td.page-cell .page-query {
+  display: inline-block;
+  margin-top: 4px;
+  padding: 1px 8px;
+  font-size: 11px;
+  color: ${COLORS.textMuted};
+  background: ${COLORS.surface};
+  border: 1px solid ${COLORS.border};
+  border-radius: 999px;
+  cursor: help;
+}
+table.report-table td .badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 600;
+  border: 1px solid;
+}
+.cell-cited { color: ${COLORS.positive}; font-weight: 600; }
+.cell-not-cited { color: ${COLORS.textFaint}; }
+.cell-pending { color: ${COLORS.textFaint}; font-style: italic; }
+.tone-positive { color: ${COLORS.positive}; }
+.tone-caution { color: ${COLORS.caution}; }
+.tone-negative { color: ${COLORS.negative}; }
+.tone-neutral { color: ${COLORS.neutral}; }
+.badge.tone-positive { color: ${COLORS.positive}; border-color: ${COLORS.positive}40; background: ${COLORS.positive}14; }
+.badge.tone-caution { color: ${COLORS.caution}; border-color: ${COLORS.caution}40; background: ${COLORS.caution}14; }
+.badge.tone-negative { color: ${COLORS.negative}; border-color: ${COLORS.negative}40; background: ${COLORS.negative}14; }
+.badge.tone-neutral { color: ${COLORS.textMuted}; border-color: ${COLORS.border}; background: transparent; }
+.chart-card {
+  background: ${COLORS.surface};
+  border: 1px solid ${COLORS.border};
+  border-radius: 8px;
+  padding: 20px;
+  margin-bottom: 16px;
+}
+.chart-card h3 {
+  font-size: 14px;
+  font-weight: 600;
+  margin: 0 0 16px;
+}
+.chart-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(360px, 1fr));
+  gap: 16px;
+}
+.legend {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 12px;
+  font-size: 12px;
+  margin-top: 12px;
+}
+.legend-swatch {
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  border-radius: 2px;
+  margin-right: 6px;
+  vertical-align: middle;
+}
+.empty-state {
+  background: ${COLORS.surface};
+  border: 1px dashed ${COLORS.border};
+  border-radius: 8px;
+  padding: 32px;
+  color: ${COLORS.textMuted};
+  text-align: center;
+  font-size: 13px;
+}
+.steps {
+  display: grid;
+  gap: 12px;
+}
+.step {
+  background: ${COLORS.surface};
+  border: 1px solid ${COLORS.border};
+  border-radius: 8px;
+  padding: 16px 20px;
+  display: grid;
+  gap: 4px;
+}
+.step .horizon {
+  text-transform: uppercase;
+  font-size: 10px;
+  letter-spacing: 0.08em;
+  color: ${COLORS.textFaint};
+  font-weight: 600;
+}
+.step .title { font-weight: 600; }
+.step .rationale { color: ${COLORS.textMuted}; font-size: 13px; }
+.footer {
+  margin-top: 96px;
+  padding-top: 24px;
+  border-top: 1px solid ${COLORS.border};
+  text-align: center;
+  color: ${COLORS.textFaint};
+  font-size: 12px;
+}
+@media print {
+  body { background: white; color: black; }
+  section.report-section { break-inside: avoid; }
+}
+`;
+function section(opts, body) {
+  return `<section class="report-section" id="${escapeHtml(opts.id)}">
+    <div class="eyebrow">${escapeHtml(opts.eyebrow)}</div>
+    <h2>${escapeHtml(opts.title)}</h2>
+    ${opts.intro ? `<p class="section-intro">${escapeHtml(opts.intro)}</p>` : ""}
+    ${body}
+  </section>`;
+}
+function renderEmpty(message) {
+  return `<div class="empty-state">${escapeHtml(message)}</div>`;
+}
+function renderExecutiveSummary(report) {
+  const s = report.executiveSummary;
+  const trendLabel = s.trend === "up" ? "\u2191 Up" : s.trend === "down" ? "\u2193 Down" : s.trend === "flat" ? "\u2192 Flat" : "\u2014";
+  const trendTone = s.trend === "up" ? "positive" : s.trend === "down" ? "negative" : "neutral";
+  const metrics = [
+    {
+      label: "Citation rate",
+      value: `${s.citationRate}%`,
+      delta: `<span class="tone-${trendTone}">${trendLabel}</span> \xB7 ${s.providerCount} provider${s.providerCount === 1 ? "" : "s"}`
+    },
+    {
+      label: "Keywords tracked",
+      value: formatNumber(s.keywordCount),
+      delta: `${s.competitorCount} competitor${s.competitorCount === 1 ? "" : "s"} tracked`
+    }
+  ];
+  if (s.gsc) {
+    metrics.push({
+      label: "GSC clicks",
+      value: formatNumber(s.gsc.clicks),
+      delta: `${formatNumber(s.gsc.impressions)} imp \xB7 ${formatRatio(s.gsc.ctr)} CTR`
+    });
+  }
+  if (s.ga) {
+    metrics.push({
+      label: "GA sessions",
+      value: formatNumber(s.ga.sessions),
+      delta: `${formatNumber(s.ga.users)} users \xB7 ${formatDate(s.ga.periodStart)} \u2192 ${formatDate(s.ga.periodEnd)}`
+    });
+  }
+  const metricsHtml = `<div class="metric-grid">
+    ${metrics.map((m) => `<div class="metric">
+      <div class="label">${escapeHtml(m.label)}</div>
+      <div class="value">${m.value}</div>
+      <div class="delta">${m.delta}</div>
+    </div>`).join("")}
+  </div>`;
+  const findingsHtml = s.findings.length > 0 ? `<div class="findings">${s.findings.map((f) => `
+        <div class="finding tone-${f.tone}">
+          <strong>${escapeHtml(f.title)}</strong>
+          <span>${escapeHtml(f.detail)}</span>
+        </div>`).join("")}</div>` : "";
+  return section(
+    { id: "executive-summary", eyebrow: "Section 1", title: "Executive Summary" },
+    metricsHtml + findingsHtml
+  );
+}
+function renderProviderBars(rates) {
+  if (rates.length === 0) return "";
+  const max = Math.max(...rates.map((r) => r.citationRate), 100);
+  const width = 600;
+  const height = Math.max(rates.length * 32 + 24, 80);
+  const labelWidth = 80;
+  const padding = 8;
+  const barWidth = width - labelWidth - padding * 2;
+  const bars = rates.map((r, i) => {
+    const y = i * 32 + padding;
+    const barHeight = 22;
+    const w = max > 0 ? r.citationRate / max * barWidth : 0;
+    const color = COLORS.series[i % COLORS.series.length];
+    return `
+      <text x="${labelWidth - 8}" y="${y + 16}" fill="${COLORS.textMuted}" font-size="11" text-anchor="end">${escapeHtml(r.provider)}</text>
+      <rect x="${labelWidth}" y="${y}" width="${barWidth}" height="${barHeight}" fill="${COLORS.border}" opacity="0.4" rx="3" />
+      <rect x="${labelWidth}" y="${y}" width="${w}" height="${barHeight}" fill="${color}" rx="3" />
+      <text x="${labelWidth + w + 6}" y="${y + 16}" fill="${COLORS.text}" font-size="11">${r.citationRate}% (${r.citedCount}/${r.totalCount})</text>`;
+  }).join("");
+  return `<div class="chart-card">
+    <h3>Provider citation rate</h3>
+    <svg viewBox="0 0 ${width} ${height}" width="100%" preserveAspectRatio="xMinYMin meet" role="img" aria-label="Provider citation rate bar chart">
+      ${bars}
+    </svg>
+  </div>`;
+}
+function renderCitationMatrix(scorecard) {
+  if (scorecard.keywords.length === 0 || scorecard.providers.length === 0) {
+    return renderEmpty("Run a visibility sweep to populate the citation matrix.");
+  }
+  const headers = scorecard.providers.map((p) => `<th>${escapeHtml(p)}</th>`).join("");
+  const rows = scorecard.keywords.map((kw, ki) => {
+    const cells = scorecard.providers.map((_, pi) => {
+      const cell = scorecard.matrix[ki]?.[pi];
+      if (!cell) {
+        return '<td><span class="cell-pending">\u2014</span></td>';
+      }
+      if (cell.citationState === "cited") {
+        return '<td><span class="cell-cited">Cited</span></td>';
+      }
+      return '<td><span class="cell-not-cited">Not cited</span></td>';
+    }).join("");
+    return `<tr><td>${escapeHtml(kw)}</td>${cells}</tr>`;
+  }).join("");
+  return `<table class="report-table">
+    <thead><tr><th>Keyword</th>${headers}</tr></thead>
+    <tbody>${rows}</tbody>
+  </table>`;
+}
+function renderCitationScorecard(report) {
+  const body = `
+    ${renderProviderBars(report.citationScorecard.providerRates)}
+    ${renderCitationMatrix(report.citationScorecard)}
+  `;
+  return section(
+    { id: "citation-scorecard", eyebrow: "Section 2", title: "Citation Scorecard", intro: "Per-keyword \xD7 per-provider citation matrix from the latest visibility sweep." },
+    body
+  );
+}
+function renderCompetitorBars(landscape, canonical) {
+  const data = [
+    { label: canonical, count: landscape.projectCitationCount, isProject: true },
+    ...landscape.competitors.map((c) => ({ label: c.domain, count: c.citationCount, isProject: false }))
+  ];
+  if (data.length <= 1) return "";
+  const max = Math.max(...data.map((d) => d.count), 1);
+  const width = 600;
+  const height = data.length * 28 + 16;
+  const labelWidth = 160;
+  const bars = data.map((d, i) => {
+    const y = i * 28 + 8;
+    const barHeight = 18;
+    const w = d.count / max * (width - labelWidth - 60);
+    const color = d.isProject ? COLORS.accent : COLORS.series[(i + 1) % COLORS.series.length];
+    return `
+      <text x="${labelWidth - 8}" y="${y + 13}" fill="${COLORS.textMuted}" font-size="11" text-anchor="end">${escapeHtml(d.label)}</text>
+      <rect x="${labelWidth}" y="${y}" width="${w}" height="${barHeight}" fill="${color}" rx="3" />
+      <text x="${labelWidth + w + 6}" y="${y + 13}" fill="${COLORS.text}" font-size="11">${d.count}</text>`;
+  }).join("");
+  return `<div class="chart-card">
+    <h3>Citations per domain</h3>
+    <svg viewBox="0 0 ${width} ${height}" width="100%" preserveAspectRatio="xMinYMin meet" role="img" aria-label="Citations per domain bar chart">
+      ${bars}
+    </svg>
+  </div>`;
+}
+function renderCompetitorLandscape(report) {
+  const competitors2 = report.competitorLandscape.competitors;
+  if (competitors2.length === 0 && report.competitorLandscape.projectCitationCount === 0) {
+    return section(
+      { id: "competitor-landscape", eyebrow: "Section 3", title: "Competitor Landscape" },
+      renderEmpty("No competitor data yet. Add competitors and run a visibility sweep.")
+    );
+  }
+  const rows = competitors2.map((c) => {
+    const tone = pressureTone(c.pressureLabel);
+    return `<tr>
+      <td>${escapeHtml(c.domain)}</td>
+      <td><span class="badge tone-${tone}">${escapeHtml(c.pressureLabel)}</span></td>
+      <td class="numeric">${c.citationCount} / ${c.totalCount}</td>
+      <td>${escapeHtml(c.citedKeywords.slice(0, 5).join(", "))}${c.citedKeywords.length > 5 ? "\u2026" : ""}</td>
+    </tr>`;
+  }).join("");
+  const table = competitors2.length > 0 ? `<table class="report-table">
+        <thead><tr><th>Domain</th><th>Pressure</th><th>Citations</th><th>Cited keywords</th></tr></thead>
+        <tbody>${rows}</tbody>
+      </table>` : renderEmpty("No competitors configured.");
+  return section(
+    { id: "competitor-landscape", eyebrow: "Section 3", title: "Competitor Landscape", intro: "Where tracked competitors appear in AI answers compared to your domain." },
+    `${renderCompetitorBars(report.competitorLandscape, report.meta.project.canonicalDomain)}${table}`
+  );
+}
+function renderDonut(buckets) {
+  if (buckets.length === 0) return "";
+  const total = buckets.reduce((s, b) => s + b.count, 0);
+  if (total === 0) return "";
+  const cx = 110;
+  const cy = 110;
+  const r = 80;
+  const innerR = 48;
+  let cumulative = 0;
+  const slices = [];
+  const legend = [];
+  buckets.forEach((b, i) => {
+    const startAngle = cumulative / total * Math.PI * 2 - Math.PI / 2;
+    const endAngle = (cumulative + b.count) / total * Math.PI * 2 - Math.PI / 2;
+    cumulative += b.count;
+    const x1 = cx + Math.cos(startAngle) * r;
+    const y1 = cy + Math.sin(startAngle) * r;
+    const x2 = cx + Math.cos(endAngle) * r;
+    const y2 = cy + Math.sin(endAngle) * r;
+    const ix1 = cx + Math.cos(endAngle) * innerR;
+    const iy1 = cy + Math.sin(endAngle) * innerR;
+    const ix2 = cx + Math.cos(startAngle) * innerR;
+    const iy2 = cy + Math.sin(startAngle) * innerR;
+    const largeArc = endAngle - startAngle > Math.PI ? 1 : 0;
+    const color = COLORS.series[i % COLORS.series.length];
+    if (b.count > 0) {
+      slices.push(`<path d="M ${x1} ${y1} A ${r} ${r} 0 ${largeArc} 1 ${x2} ${y2} L ${ix1} ${iy1} A ${innerR} ${innerR} 0 ${largeArc} 0 ${ix2} ${iy2} Z" fill="${color}" />`);
+      legend.push(`<span><span class="legend-swatch" style="background:${color}"></span>${escapeHtml(b.label)} (${b.count})</span>`);
+    }
+  });
+  return `<div class="chart-card">
+    <h3>AI source categories</h3>
+    <div style="display:flex;align-items:center;gap:24px;flex-wrap:wrap;">
+      <svg viewBox="0 0 220 220" width="220" height="220" role="img" aria-label="AI source category donut chart">
+        ${slices.join("")}
+      </svg>
+      <div class="legend" style="flex-direction:column;align-items:flex-start;gap:6px;">${legend.join("")}</div>
+    </div>
+  </div>`;
+}
+function renderAiSourceOrigin(report) {
+  const origin = report.aiSourceOrigin;
+  if (origin.categories.length === 0 && origin.topDomains.length === 0) {
+    return section(
+      { id: "ai-source-origin", eyebrow: "Section 4", title: "AI Source Origin" },
+      renderEmpty("No source data yet. Run a visibility sweep first.")
+    );
+  }
+  const rows = origin.topDomains.map((d) => `
+    <tr>
+      <td>${escapeHtml(d.domain)}</td>
+      <td class="numeric">${d.count}</td>
+      <td>${d.isCompetitor ? '<span class="badge tone-negative">Competitor</span>' : '<span class="badge tone-neutral">External</span>'}</td>
+    </tr>`).join("");
+  const table = origin.topDomains.length > 0 ? `<table class="report-table">
+        <thead><tr><th>Domain</th><th>Citations</th><th>Tag</th></tr></thead>
+        <tbody>${rows}</tbody>
+      </table>` : "";
+  return section(
+    { id: "ai-source-origin", eyebrow: "Section 4", title: "AI Source Origin", intro: "Where AI answers pull from, aggregated across the latest sweep." },
+    `${renderDonut(origin.categories)}${table}`
+  );
+}
+function renderLineChart(points, color, title, height = 200) {
+  if (points.length === 0) return "";
+  const width = 600;
+  const padX = 32;
+  const padY = 24;
+  const usableW = width - padX * 2;
+  const usableH = height - padY * 2;
+  const max = Math.max(...points.map((p) => p.y), 1);
+  const stepX = points.length > 1 ? usableW / (points.length - 1) : 0;
+  const xy = points.map((p, i) => ({
+    x: padX + i * stepX,
+    y: padY + usableH - p.y / max * usableH,
+    raw: p
+  }));
+  const path10 = xy.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`).join(" ");
+  const dots = xy.map((p) => `<circle cx="${p.x.toFixed(1)}" cy="${p.y.toFixed(1)}" r="3" fill="${color}" />`).join("");
+  const xLabels = xy.map((p, i) => {
+    if (points.length > 8 && i % Math.ceil(points.length / 6) !== 0 && i !== points.length - 1) return "";
+    return `<text x="${p.x.toFixed(1)}" y="${(height - 4).toFixed(1)}" fill="${COLORS.textFaint}" font-size="9" text-anchor="middle">${escapeHtml(p.raw.label ?? p.raw.x)}</text>`;
+  }).join("");
+  return `<div class="chart-card">
+    <h3>${escapeHtml(title)}</h3>
+    <svg viewBox="0 0 ${width} ${height}" width="100%" preserveAspectRatio="xMinYMin meet" role="img" aria-label="${escapeHtml(title)} line chart">
+      <line x1="${padX}" y1="${padY + usableH}" x2="${padX + usableW}" y2="${padY + usableH}" stroke="${COLORS.border}" stroke-width="1" />
+      <text x="${padX - 6}" y="${(padY + 4).toFixed(1)}" fill="${COLORS.textFaint}" font-size="9" text-anchor="end">${formatNumber(max)}</text>
+      <text x="${padX - 6}" y="${(padY + usableH).toFixed(1)}" fill="${COLORS.textFaint}" font-size="9" text-anchor="end">0</text>
+      <path d="${path10}" stroke="${color}" stroke-width="2" fill="none" />
+      ${dots}
+      ${xLabels}
+    </svg>
+  </div>`;
+}
+function renderGsc(report) {
+  const gsc = report.gsc;
+  if (!gsc) {
+    return section(
+      { id: "gsc", eyebrow: "Section 5", title: "GSC Performance" },
+      renderEmpty("Connect Google Search Console to populate this section.")
+    );
+  }
+  const rows = gsc.topQueries.map((q) => `
+    <tr>
+      <td>${escapeHtml(q.query)}</td>
+      <td class="numeric">${formatNumber(q.clicks)}</td>
+      <td class="numeric">${formatNumber(q.impressions)}</td>
+      <td class="numeric">${formatRatio(q.ctr)}</td>
+      <td class="numeric">${q.avgPosition.toFixed(1)}</td>
+      <td><span class="badge tone-neutral">${escapeHtml(q.category)}</span></td>
+    </tr>`).join("");
+  const breakdownRows = gsc.categoryBreakdown.map((c) => `
+    <tr>
+      <td>${escapeHtml(c.category)}</td>
+      <td class="numeric">${formatNumber(c.clicks)}</td>
+      <td class="numeric">${formatNumber(c.impressions)}</td>
+      <td class="numeric">${c.sharePct}%</td>
+    </tr>`).join("");
+  const trendChart = renderLineChart(
+    gsc.trend.map((t) => ({ x: t.date, y: t.clicks, label: t.date.slice(5) })),
+    COLORS.accent,
+    "Clicks over time"
+  );
+  return section(
+    { id: "gsc", eyebrow: "Section 5", title: "GSC Performance", intro: "Top queries, category breakdown, and traffic trend from Google Search Console." },
+    `<div class="metric-grid">
+      <div class="metric"><div class="label">Total clicks</div><div class="value">${formatNumber(gsc.totalClicks)}</div></div>
+      <div class="metric"><div class="label">Total impressions</div><div class="value">${formatNumber(gsc.totalImpressions)}</div></div>
+      <div class="metric"><div class="label">Avg CTR</div><div class="value">${formatRatio(gsc.ctr)}</div></div>
+      <div class="metric"><div class="label">Avg position</div><div class="value">${gsc.avgPosition.toFixed(1)}</div></div>
+    </div>
+    ${trendChart}
+    <div class="chart-card"><h3>Top queries</h3>
+      <table class="report-table">
+        <thead><tr><th>Query</th><th class="numeric">Clicks</th><th class="numeric">Imp.</th><th class="numeric">CTR</th><th class="numeric">Pos.</th><th>Category</th></tr></thead>
+        <tbody>${rows}</tbody>
+      </table>
+    </div>
+    <div class="chart-card"><h3>Category breakdown</h3>
+      <table class="report-table">
+        <thead><tr><th>Category</th><th class="numeric">Clicks</th><th class="numeric">Imp.</th><th class="numeric">Share</th></tr></thead>
+        <tbody>${breakdownRows}</tbody>
+      </table>
+    </div>`
+  );
+}
+function renderGa(report) {
+  const ga = report.ga;
+  if (!ga) {
+    return section(
+      { id: "ga", eyebrow: "Section 6", title: "GA4 Traffic" },
+      renderEmpty("Connect Google Analytics 4 to populate this section.")
+    );
+  }
+  const pageRows = ga.topLandingPages.map((p) => `
+    <tr>
+      <td class="page-cell">${formatLandingPageHtml(p.page)}</td>
+      <td class="numeric">${formatNumber(p.sessions)}</td>
+      <td class="numeric">${formatNumber(p.users)}</td>
+      <td class="numeric">${formatNumber(p.organicSessions)}</td>
+    </tr>`).join("");
+  const channelRows = ga.channelBreakdown.map((c) => `
+    <tr>
+      <td>${escapeHtml(c.channel)}</td>
+      <td class="numeric">${formatNumber(c.sessions)}</td>
+      <td class="numeric">${c.sharePct}%</td>
+    </tr>`).join("");
+  return section(
+    { id: "ga", eyebrow: "Section 6", title: "GA4 Traffic", intro: `Sessions and users for ${formatDate(ga.periodStart)} \u2192 ${formatDate(ga.periodEnd)}.` },
+    `<div class="metric-grid">
+      <div class="metric"><div class="label">Total sessions</div><div class="value">${formatNumber(ga.totalSessions)}</div></div>
+      <div class="metric"><div class="label">Total users</div><div class="value">${formatNumber(ga.totalUsers)}</div></div>
+      <div class="metric"><div class="label">Organic sessions</div><div class="value">${formatNumber(ga.totalOrganicSessions)}</div></div>
+    </div>
+    <div class="chart-card"><h3>Top landing pages</h3>
+      <table class="report-table">
+        <thead><tr><th>Page</th><th class="numeric">Sessions</th><th class="numeric">Users</th><th class="numeric">Organic</th></tr></thead>
+        <tbody>${pageRows}</tbody>
+      </table>
+    </div>
+    <div class="chart-card"><h3>Channel breakdown</h3>
+      <table class="report-table">
+        <thead><tr><th>Channel</th><th class="numeric">Sessions</th><th class="numeric">Share</th></tr></thead>
+        <tbody>${channelRows}</tbody>
+      </table>
+    </div>`
+  );
+}
+function renderSocial(report) {
+  const social = report.socialReferrals;
+  if (!social) {
+    return section(
+      { id: "social-referrals", eyebrow: "Section 7", title: "Social Referrals" },
+      renderEmpty("No social referral data yet.")
+    );
+  }
+  const channelRows = social.channels.map((c) => `
+    <tr>
+      <td>${escapeHtml(c.channelGroup)}</td>
+      <td class="numeric">${formatNumber(c.sessions)}</td>
+      <td class="numeric">${c.sharePct}%</td>
+    </tr>`).join("");
+  const campaignRows = social.topCampaigns.map((c) => `
+    <tr>
+      <td>${escapeHtml(c.source)}</td>
+      <td>${escapeHtml(c.medium)}</td>
+      <td class="numeric">${formatNumber(c.sessions)}</td>
+    </tr>`).join("");
+  return section(
+    { id: "social-referrals", eyebrow: "Section 7", title: "Social Referrals", intro: "Paid vs organic split with top campaigns." },
+    `<div class="metric-grid">
+      <div class="metric"><div class="label">Total sessions</div><div class="value">${formatNumber(social.totalSessions)}</div></div>
+      <div class="metric"><div class="label">Organic social</div><div class="value">${formatNumber(social.organicSessions)}</div></div>
+      <div class="metric"><div class="label">Paid social</div><div class="value">${formatNumber(social.paidSessions)}</div></div>
+    </div>
+    <div class="chart-card"><h3>Channel groups</h3>
+      <table class="report-table">
+        <thead><tr><th>Channel</th><th class="numeric">Sessions</th><th class="numeric">Share</th></tr></thead>
+        <tbody>${channelRows}</tbody>
+      </table>
+    </div>
+    <div class="chart-card"><h3>Top campaigns</h3>
+      <table class="report-table">
+        <thead><tr><th>Source</th><th>Medium</th><th class="numeric">Sessions</th></tr></thead>
+        <tbody>${campaignRows}</tbody>
+      </table>
+    </div>`
+  );
+}
+function renderAiReferrals(report) {
+  const ai = report.aiReferrals;
+  if (!ai) {
+    return section(
+      { id: "ai-referrals", eyebrow: "Section 8", title: "AI Referral Traffic" },
+      renderEmpty("No AI referral traffic detected yet.")
+    );
+  }
+  const sourceRows = ai.bySource.map((s) => `
+    <tr>
+      <td>${escapeHtml(s.source)}</td>
+      <td class="numeric">${formatNumber(s.sessions)}</td>
+      <td class="numeric">${formatNumber(s.users)}</td>
+      <td class="numeric">${s.sharePct}%</td>
+    </tr>`).join("");
+  const pageRows = ai.topLandingPages.map((p) => `
+    <tr>
+      <td class="page-cell">${formatLandingPageHtml(p.page)}</td>
+      <td class="numeric">${formatNumber(p.sessions)}</td>
+      <td class="numeric">${formatNumber(p.users)}</td>
+    </tr>`).join("");
+  const trendChart = renderLineChart(
+    ai.trend.map((t) => ({ x: t.date, y: t.sessions, label: t.date.slice(5) })),
+    COLORS.series[2],
+    "AI referral sessions over time"
+  );
+  return section(
+    { id: "ai-referrals", eyebrow: "Section 8", title: "AI Referral Traffic", intro: "Sessions sent from AI answer engines." },
+    `<div class="metric-grid">
+      <div class="metric"><div class="label">Total sessions</div><div class="value">${formatNumber(ai.totalSessions)}</div></div>
+      <div class="metric"><div class="label">Total users</div><div class="value">${formatNumber(ai.totalUsers)}</div></div>
+    </div>
+    ${trendChart}
+    <div class="chart-card"><h3>Sessions by source</h3>
+      <table class="report-table">
+        <thead><tr><th>Source</th><th class="numeric">Sessions</th><th class="numeric">Users</th><th class="numeric">Share</th></tr></thead>
+        <tbody>${sourceRows}</tbody>
+      </table>
+    </div>
+    <div class="chart-card"><h3>Top AI landing pages</h3>
+      <table class="report-table">
+        <thead><tr><th>Page</th><th class="numeric">Sessions</th><th class="numeric">Users</th></tr></thead>
+        <tbody>${pageRows}</tbody>
+      </table>
+    </div>`
+  );
+}
+function renderIndexingHealth(report) {
+  const ih = report.indexingHealth;
+  if (!ih) {
+    return section(
+      { id: "indexing-health", eyebrow: "Section 9", title: "Indexing Health" },
+      renderEmpty("Connect Google Search Console or Bing Webmaster Tools and run a sitemap inspection.")
+    );
+  }
+  const segments = [
+    { label: "Indexed", count: ih.indexed, color: COLORS.positive },
+    { label: "Not indexed", count: ih.notIndexed, color: COLORS.caution },
+    { label: "Deindexed", count: ih.deindexed, color: COLORS.negative },
+    { label: "Unknown", count: ih.unknown, color: COLORS.neutral }
+  ].filter((s) => s.count > 0);
+  const total = segments.reduce((s, x) => s + x.count, 0) || 1;
+  const width = 600;
+  const height = 28;
+  let acc = 0;
+  const bars = segments.map((s) => {
+    const w = s.count / total * width;
+    const x = acc;
+    acc += w;
+    return `<rect x="${x}" y="0" width="${w}" height="${height}" fill="${s.color}" />`;
+  }).join("");
+  const legend = segments.map((s) => `<span><span class="legend-swatch" style="background:${s.color}"></span>${escapeHtml(s.label)}: ${s.count}</span>`).join("");
+  return section(
+    { id: "indexing-health", eyebrow: "Section 9", title: "Indexing Health", intro: `Source: ${ih.provider === "google" ? "Google Search Console" : "Bing Webmaster Tools"}.` },
+    `<div class="metric-grid">
+      <div class="metric"><div class="label">Indexed</div><div class="value tone-positive">${formatNumber(ih.indexed)}</div></div>
+      <div class="metric"><div class="label">Total inspected</div><div class="value">${formatNumber(ih.total)}</div></div>
+      <div class="metric"><div class="label">Indexed share</div><div class="value">${ih.indexedPct}%</div></div>
+    </div>
+    <div class="chart-card">
+      <h3>Coverage breakdown</h3>
+      <svg viewBox="0 0 ${width} ${height}" width="100%" preserveAspectRatio="xMinYMin meet" role="img" aria-label="Coverage stacked bar">${bars}</svg>
+      <div class="legend">${legend}</div>
+    </div>`
+  );
+}
+function renderCitationsTrend(report) {
+  const trend = report.citationsTrend;
+  if (trend.length === 0) {
+    return section(
+      { id: "citations-trend", eyebrow: "Section 10", title: "Citations Over Time" },
+      renderEmpty("Run multiple visibility sweeps to see a trend.")
+    );
+  }
+  const chart = renderLineChart(
+    trend.map((t) => ({ x: t.date, y: t.citationRate, label: formatDate(t.date) })),
+    COLORS.positive,
+    "Overall citation rate",
+    220
+  );
+  const rows = trend.map((t) => `
+    <tr>
+      <td>${formatDate(t.date)}</td>
+      <td class="numeric">${t.citationRate}%</td>
+      <td>${t.providerRates.map((r) => `${escapeHtml(r.provider)}: ${r.citationRate}%`).join(" \xB7 ")}</td>
+    </tr>`).join("");
+  return section(
+    { id: "citations-trend", eyebrow: "Section 10", title: "Citations Over Time", intro: "Per-run citation rate across the project history." },
+    `${chart}
+    <div class="chart-card"><h3>Run-by-run breakdown</h3>
+      <table class="report-table">
+        <thead><tr><th>Run</th><th class="numeric">Overall rate</th><th>Per-provider rates</th></tr></thead>
+        <tbody>${rows}</tbody>
+      </table>
+    </div>`
+  );
+}
+function renderInsights(report) {
+  const list = report.insights;
+  if (list.length === 0) {
+    return section(
+      { id: "insights", eyebrow: "Section 11", title: "Insights & Alerts" },
+      renderEmpty("No insights yet \u2014 run a visibility sweep to generate alerts.")
+    );
+  }
+  const rows = list.map((i) => {
+    const tone = severityTone(i.severity);
+    return `<tr>
+      <td><span class="badge tone-${tone}">${escapeHtml(i.severity)}</span></td>
+      <td>${escapeHtml(i.title)}</td>
+      <td>${escapeHtml(i.keyword)}</td>
+      <td>${escapeHtml(i.provider)}</td>
+      <td>${i.recommendation ? escapeHtml(i.recommendation) : '<span class="cell-pending">\u2014</span>'}</td>
+    </tr>`;
+  }).join("");
+  return section(
+    { id: "insights", eyebrow: "Section 11", title: "Insights & Alerts", intro: "Priority-ordered findings from the most recent runs." },
+    `<table class="report-table">
+      <thead><tr><th>Severity</th><th>Title</th><th>Keyword</th><th>Provider</th><th>Recommendation</th></tr></thead>
+      <tbody>${rows}</tbody>
+    </table>`
+  );
+}
+function renderRecommendedNextSteps(report) {
+  const steps = report.recommendedNextSteps;
+  if (steps.length === 0) {
+    return section(
+      { id: "recommended-next-steps", eyebrow: "Section 12", title: "Recommended Next Steps" },
+      renderEmpty("No outstanding actions.")
+    );
+  }
+  const items = steps.map((s) => `
+    <div class="step">
+      <span class="horizon">${escapeHtml(s.horizon)}</span>
+      <span class="title">${escapeHtml(s.title)}</span>
+      <span class="rationale">${escapeHtml(s.rationale)}</span>
+    </div>`).join("");
+  return section(
+    { id: "recommended-next-steps", eyebrow: "Section 12", title: "Recommended Next Steps" },
+    `<div class="steps">${items}</div>`
+  );
+}
+function escapeJsonForScript(json) {
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function renderReportHtml(report, opts = {}) {
+  const title = opts.title ?? `Canonry report \u2014 ${report.meta.project.displayName}`;
+  const sections = [
+    renderExecutiveSummary(report),
+    renderCitationScorecard(report),
+    renderCompetitorLandscape(report),
+    renderAiSourceOrigin(report),
+    renderGsc(report),
+    renderGa(report),
+    renderSocial(report),
+    renderAiReferrals(report),
+    renderIndexingHealth(report),
+    renderCitationsTrend(report),
+    renderInsights(report),
+    renderRecommendedNextSteps(report)
+  ].join("\n");
+  const json = escapeJsonForScript(JSON.stringify(report));
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>${escapeHtml(title)}</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<div class="container">
+  <header class="header">
+    <div class="eyebrow">AEO Report</div>
+    <h1>${escapeHtml(report.meta.project.displayName)}</h1>
+    <div class="subtitle">${escapeHtml(report.meta.project.canonicalDomain)} \xB7 ${escapeHtml(report.meta.project.country)} / ${escapeHtml(report.meta.project.language.toUpperCase())} \xB7 Generated ${formatDate(report.meta.generatedAt)}</div>
+  </header>
+  ${sections}
+  <footer class="footer">Generated by canonry \xB7 ${escapeHtml(report.meta.generatedAt)}</footer>
+</div>
+<script type="application/json" id="canonry-report-data">${json}</script>
+</body>
+</html>`;
+}
+
+// src/commands/report.ts
+function defaultOutputPath(project) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return path3.resolve(process.cwd(), `canonry-report-${project}-${date}.html`);
+}
+async function runReportCommand(project, opts = {}) {
+  const client = createApiClient();
+  const report = await client.getReport(project);
+  if (opts.format === "json") {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  const html = renderReportHtml(report);
+  const targetPath = opts.output ? path3.resolve(opts.output) : defaultOutputPath(project);
+  const dir = path3.dirname(targetPath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+  fs4.writeFileSync(targetPath, html, "utf-8");
+  console.log(`Report written to ${targetPath}`);
+}
+
+// src/cli-commands/report.ts
+var USAGE2 = "canonry report <project> [--output <path>] [--format json]";
+var REPORT_CLI_COMMANDS = [
+  {
+    path: ["report"],
+    usage: USAGE2,
+    options: {
+      output: { type: "string", short: "o" }
+    },
+    run: async (input) => {
+      const project = requireProject(input, "report", USAGE2);
+      await runReportCommand(project, {
+        format: input.format,
+        output: getString(input.values, "output")
+      });
+    }
+  }
+];
+
 // src/commands/run.ts
 function getClient14() {
   return createApiClient();
@@ -5882,19 +6864,19 @@ Usage: canonry settings provider ${name} --api-key <key> [--model <model>] [--ma
 ];
 
 // src/commands/skills.ts
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 var BUNDLED_SKILL_NAMES = ["canonry-setup", "aero"];
 function resolveBundledSkillsRoot(pkgDir) {
-  const here = pkgDir ?? path3.dirname(fileURLToPath(import.meta.url));
+  const here = pkgDir ?? path4.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path3.join(here, "../assets/agent-workspace/skills"),
-    path3.join(here, "../../assets/agent-workspace/skills"),
-    path3.join(here, "../../../../skills")
+    path4.join(here, "../assets/agent-workspace/skills"),
+    path4.join(here, "../../assets/agent-workspace/skills"),
+    path4.join(here, "../../../../skills")
   ];
   for (const candidate of candidates) {
-    if (BUNDLED_SKILL_NAMES.every((name) => fs4.existsSync(path3.join(candidate, name, "SKILL.md")))) {
+    if (BUNDLED_SKILL_NAMES.every((name) => fs5.existsSync(path4.join(candidate, name, "SKILL.md")))) {
       return candidate;
     }
   }
@@ -5915,17 +6897,17 @@ function parseDescription(content) {
 function getBundledSkills(pkgDir) {
   const root = resolveBundledSkillsRoot(pkgDir);
   return BUNDLED_SKILL_NAMES.map((name) => {
-    const skillDir = path3.join(root, name);
-    const skillFile = path3.join(skillDir, "SKILL.md");
-    const content = fs4.readFileSync(skillFile, "utf-8");
+    const skillDir = path4.join(root, name);
+    const skillFile = path4.join(skillDir, "SKILL.md");
+    const content = fs5.readFileSync(skillFile, "utf-8");
     return { name, description: parseDescription(content), bundledPath: skillDir };
   });
 }
 function walkRelative(dir, prefix = "") {
   const out = [];
-  for (const entry of fs4.readdirSync(dir, { withFileTypes: true })) {
-    const rel = prefix ? path3.join(prefix, entry.name) : entry.name;
-    const full = path3.join(dir, entry.name);
+  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+    const rel = prefix ? path4.join(prefix, entry.name) : entry.name;
+    const full = path4.join(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...walkRelative(full, rel));
     } else if (entry.isFile()) {
@@ -5935,33 +6917,33 @@ function walkRelative(dir, prefix = "") {
   return out.sort();
 }
 function compareDirContent(srcDir, destDir) {
-  if (!fs4.existsSync(destDir)) return "missing";
-  if (!fs4.statSync(destDir).isDirectory()) return "different";
+  if (!fs5.existsSync(destDir)) return "missing";
+  if (!fs5.statSync(destDir).isDirectory()) return "different";
   const srcFiles = walkRelative(srcDir);
   const destFiles = walkRelative(destDir);
   if (srcFiles.length !== destFiles.length) return "different";
   for (let i = 0; i < srcFiles.length; i++) {
     if (srcFiles[i] !== destFiles[i]) return "different";
-    const srcBytes = fs4.readFileSync(path3.join(srcDir, srcFiles[i]));
-    const destBytes = fs4.readFileSync(path3.join(destDir, destFiles[i]));
+    const srcBytes = fs5.readFileSync(path4.join(srcDir, srcFiles[i]));
+    const destBytes = fs5.readFileSync(path4.join(destDir, destFiles[i]));
     if (!srcBytes.equals(destBytes)) return "different";
   }
   return "match";
 }
 function copyDirRecursive(src, dest) {
-  fs4.mkdirSync(dest, { recursive: true });
-  for (const entry of fs4.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path3.join(src, entry.name);
-    const destPath = path3.join(dest, entry.name);
+  fs5.mkdirSync(dest, { recursive: true });
+  for (const entry of fs5.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else if (entry.isFile()) {
-      fs4.copyFileSync(srcPath, destPath);
+      fs5.copyFileSync(srcPath, destPath);
     }
   }
 }
 function installClaudeSkill(skill, targetDir, force) {
-  const targetPath = path3.join(targetDir, ".claude", "skills", skill.name);
+  const targetPath = path4.join(targetDir, ".claude", "skills", skill.name);
   const compare = compareDirContent(skill.bundledPath, targetPath);
   if (compare === "match") {
     return {
@@ -5981,7 +6963,7 @@ function installClaudeSkill(skill, targetDir, force) {
     });
   }
   if (compare === "different") {
-    fs4.rmSync(targetPath, { recursive: true, force: true });
+    fs5.rmSync(targetPath, { recursive: true, force: true });
   }
   copyDirRecursive(skill.bundledPath, targetPath);
   return {
@@ -5993,18 +6975,18 @@ function installClaudeSkill(skill, targetDir, force) {
   };
 }
 function installCodexSymlink(skill, targetDir, force) {
-  const codexPath = path3.join(targetDir, ".codex", "skills", skill.name);
-  const claudePath = path3.join(targetDir, ".claude", "skills", skill.name);
-  const linkTarget = path3.relative(path3.dirname(codexPath), claudePath);
-  fs4.mkdirSync(path3.dirname(codexPath), { recursive: true });
+  const codexPath = path4.join(targetDir, ".codex", "skills", skill.name);
+  const claudePath = path4.join(targetDir, ".claude", "skills", skill.name);
+  const linkTarget = path4.relative(path4.dirname(codexPath), claudePath);
+  fs5.mkdirSync(path4.dirname(codexPath), { recursive: true });
   let stat;
   try {
-    stat = fs4.lstatSync(codexPath);
+    stat = fs5.lstatSync(codexPath);
   } catch {
     stat = void 0;
   }
   if (stat?.isSymbolicLink()) {
-    const existing = fs4.readlinkSync(codexPath);
+    const existing = fs5.readlinkSync(codexPath);
     if (existing === linkTarget) {
       return {
         skill: skill.name,
@@ -6022,8 +7004,8 @@ function installCodexSymlink(skill, targetDir, force) {
         exitCode: 1
       });
     }
-    fs4.unlinkSync(codexPath);
-    fs4.symlinkSync(linkTarget, codexPath);
+    fs5.unlinkSync(codexPath);
+    fs5.symlinkSync(linkTarget, codexPath);
     return {
       skill: skill.name,
       client: CodingAgents.codex,
@@ -6041,9 +7023,9 @@ function installCodexSymlink(skill, targetDir, force) {
         exitCode: 1
       });
     }
-    fs4.rmSync(codexPath, { recursive: true, force: true });
+    fs5.rmSync(codexPath, { recursive: true, force: true });
   }
-  fs4.symlinkSync(linkTarget, codexPath);
+  fs5.symlinkSync(linkTarget, codexPath);
   return {
     skill: skill.name,
     client: CodingAgents.codex,
@@ -6059,7 +7041,7 @@ function buildSummaryMessage(results) {
   return `Skills install summary: ${parts.join(", ")}.`;
 }
 async function installSkills(opts = {}) {
-  const targetDir = path3.resolve(opts.dir ?? process.cwd());
+  const targetDir = path4.resolve(opts.dir ?? process.cwd());
   const client = opts.client ?? SkillsClients.all;
   const force = opts.force ?? false;
   const allSkills = getBundledSkills();
@@ -6075,7 +7057,7 @@ async function installSkills(opts = {}) {
     });
   }
   const skillsToInstall = allSkills.filter((s) => requestedNames.includes(s.name));
-  fs4.mkdirSync(targetDir, { recursive: true });
+  fs5.mkdirSync(targetDir, { recursive: true });
   const results = [];
   for (const skill of skillsToInstall) {
     results.push(installClaudeSkill(skill, targetDir, force));
@@ -6176,12 +7158,12 @@ var SKILLS_CLI_COMMANDS = [
 ];
 
 // src/commands/snapshot.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 
 // src/snapshot-pdf.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
 var PAGE_WIDTH = 612;
 var PAGE_HEIGHT = 792;
@@ -6390,9 +7372,9 @@ async function writeSnapshotPdf(report, outputPath) {
   renderCompetitors(pdf, report);
   renderQueries(pdf, report);
   const bytes = await doc.save();
-  const resolvedPath = path4.resolve(outputPath);
-  fs5.mkdirSync(path4.dirname(resolvedPath), { recursive: true });
-  fs5.writeFileSync(resolvedPath, bytes);
+  const resolvedPath = path5.resolve(outputPath);
+  fs6.mkdirSync(path5.dirname(resolvedPath), { recursive: true });
+  fs6.writeFileSync(resolvedPath, bytes);
   return resolvedPath;
 }
 function renderCover(pdf, report) {
@@ -6550,9 +7532,9 @@ Markdown saved: ${savedMdPath}`);
 PDF saved: ${savedPdfPath}`);
 }
 function writeSnapshotMarkdown(report, outputPath) {
-  const resolvedPath = path5.resolve(outputPath);
-  fs6.mkdirSync(path5.dirname(resolvedPath), { recursive: true });
-  fs6.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
+  const resolvedPath = path6.resolve(outputPath);
+  fs7.mkdirSync(path6.dirname(resolvedPath), { recursive: true });
+  fs7.writeFileSync(resolvedPath, formatSnapshotMarkdown(report), "utf-8");
   return resolvedPath;
 }
 function formatSnapshotMarkdown(report) {
@@ -7207,7 +8189,7 @@ var CONTENT_CLI_COMMANDS = [
 
 // src/commands/bootstrap.ts
 import crypto from "crypto";
-import path6 from "path";
+import path7 from "path";
 import { eq as eq2 } from "drizzle-orm";
 
 // ../config/src/index.ts
@@ -7354,7 +8336,7 @@ async function bootstrapCommand(_opts) {
     );
   }
   const configDir = getConfigDir();
-  const databasePath = env.databasePath || path6.join(configDir, "data.db");
+  const databasePath = env.databasePath || path7.join(configDir, "data.db");
   const existing = configExists();
   const existingConfig = existing ? loadConfig() : void 0;
   let rawApiKey;
@@ -7424,10 +8406,10 @@ async function bootstrapCommand(_opts) {
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 function getPidPath() {
-  return path7.join(getConfigDir(), "canonry.pid");
+  return path8.join(getConfigDir(), "canonry.pid");
 }
 function isProcessAlive(pid) {
   try {
@@ -7454,8 +8436,8 @@ async function waitForReady(host, port, maxMs = 1e4) {
 async function startDaemon(opts) {
   const pidPath = getPidPath();
   const format = opts.format ?? "text";
-  if (fs7.existsSync(pidPath)) {
-    const existingPid = parseInt(fs7.readFileSync(pidPath, "utf-8").trim(), 10);
+  if (fs8.existsSync(pidPath)) {
+    const existingPid = parseInt(fs8.readFileSync(pidPath, "utf-8").trim(), 10);
     if (!isNaN(existingPid) && isProcessAlive(existingPid)) {
       throw new CliError({
         code: "DAEMON_ALREADY_RUNNING",
@@ -7466,9 +8448,9 @@ async function startDaemon(opts) {
         }
       });
     }
-    fs7.unlinkSync(pidPath);
+    fs8.unlinkSync(pidPath);
   }
-  const cliPath = path7.resolve(new URL(import.meta.url).pathname);
+  const cliPath = path8.resolve(new URL(import.meta.url).pathname);
   const inSourceMode = new URL(import.meta.url).pathname.endsWith(".ts");
   const args = inSourceMode ? ["--import", "tsx", cliPath, "serve"] : [cliPath, "serve"];
   if (opts.port) args.push("--port", opts.port);
@@ -7487,10 +8469,10 @@ async function startDaemon(opts) {
     });
   }
   const configDir = getConfigDir();
-  if (!fs7.existsSync(configDir)) {
-    fs7.mkdirSync(configDir, { recursive: true });
+  if (!fs8.existsSync(configDir)) {
+    fs8.mkdirSync(configDir, { recursive: true });
   }
-  fs7.writeFileSync(pidPath, String(child.pid), "utf-8");
+  fs8.writeFileSync(pidPath, String(child.pid), "utf-8");
   const port = opts.port ?? "4100";
   const host = opts.host ?? "127.0.0.1";
   if (format !== "json") {
@@ -7499,7 +8481,7 @@ async function startDaemon(opts) {
   const ready = await waitForReady(host, port);
   if (!ready) {
     try {
-      fs7.unlinkSync(pidPath);
+      fs8.unlinkSync(pidPath);
     } catch {
     }
     throw new CliError({
@@ -7531,7 +8513,7 @@ async function startDaemon(opts) {
 }
 function stopDaemon(format = "text") {
   const pidPath = getPidPath();
-  if (!fs7.existsSync(pidPath)) {
+  if (!fs8.existsSync(pidPath)) {
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: false,
@@ -7542,7 +8524,7 @@ function stopDaemon(format = "text") {
     console.log("Canonry is not running (no PID file found)");
     return;
   }
-  const pid = parseInt(fs7.readFileSync(pidPath, "utf-8").trim(), 10);
+  const pid = parseInt(fs8.readFileSync(pidPath, "utf-8").trim(), 10);
   if (isNaN(pid)) {
     if (format === "json") {
       console.log(JSON.stringify({
@@ -7553,7 +8535,7 @@ function stopDaemon(format = "text") {
     } else {
       console.error("Invalid PID file. Removing it.");
     }
-    fs7.unlinkSync(pidPath);
+    fs8.unlinkSync(pidPath);
     return;
   }
   if (!isProcessAlive(pid)) {
@@ -7567,12 +8549,12 @@ function stopDaemon(format = "text") {
     } else {
       console.log(`Canonry is not running (stale PID: ${pid}). Cleaning up.`);
     }
-    fs7.unlinkSync(pidPath);
+    fs8.unlinkSync(pidPath);
     return;
   }
   try {
     process.kill(pid, "SIGTERM");
-    fs7.unlinkSync(pidPath);
+    fs8.unlinkSync(pidPath);
     if (format === "json") {
       console.log(JSON.stringify({
         stopped: true,
@@ -7596,9 +8578,9 @@ function stopDaemon(format = "text") {
 
 // src/commands/init.ts
 import crypto2 from "crypto";
-import fs8 from "fs";
+import fs9 from "fs";
 import readline from "readline";
-import path8 from "path";
+import path9 from "path";
 function prompt(question) {
   const rl = readline.createInterface({
     input: process.stdin,
@@ -7619,8 +8601,8 @@ var DEFAULT_QUOTA = {
 var PROJECT_MARKERS = [".git", "canonry.yaml", "canonry.yml", "package.json"];
 function cwdLooksLikeProject(dir) {
   const home = process.env.HOME ?? "";
-  if (home && path8.resolve(dir) === path8.resolve(home)) return false;
-  return PROJECT_MARKERS.some((marker) => fs8.existsSync(path8.join(dir, marker)));
+  if (home && path9.resolve(dir) === path9.resolve(home)) return false;
+  return PROJECT_MARKERS.some((marker) => fs9.existsSync(path9.join(dir, marker)));
 }
 var DEFAULT_AGENT_MODELS = {
   anthropic: "anthropic/claude-sonnet-4-6",
@@ -7650,8 +8632,8 @@ async function initCommand(opts) {
     return void 0;
   }
   const configDir = getConfigDir();
-  if (!fs8.existsSync(configDir)) {
-    fs8.mkdirSync(configDir, { recursive: true });
+  if (!fs9.existsSync(configDir)) {
+    fs9.mkdirSync(configDir, { recursive: true });
   }
   const bootstrapEnv = getBootstrapEnv(process.env, {
     GEMINI_API_KEY: opts?.geminiKey,
@@ -7766,7 +8748,7 @@ async function initCommand(opts) {
   const rawApiKey = `cnry_${crypto2.randomBytes(16).toString("hex")}`;
   const keyHash = crypto2.createHash("sha256").update(rawApiKey).digest("hex");
   const keyPrefix = rawApiKey.slice(0, 9);
-  const databasePath = path8.join(configDir, "data.db");
+  const databasePath = path9.join(configDir, "data.db");
   const db = createClient(databasePath);
   migrate(db);
   db.insert(apiKeys).values({
@@ -8214,7 +9196,7 @@ var SYSTEM_CLI_COMMANDS = [
 ];
 
 // src/cli-commands/wordpress.ts
-import fs9 from "fs";
+import fs10 from "fs";
 
 // src/commands/wordpress.ts
 function getClient18() {
@@ -8450,12 +9432,12 @@ async function wordpressSetMeta(project, body) {
   printPageDetail(result);
 }
 async function wordpressBulkSetMeta(project, opts) {
-  const fs10 = await import("fs/promises");
-  const path9 = await import("path");
-  const filePath = path9.resolve(opts.from);
+  const fs11 = await import("fs/promises");
+  const path10 = await import("path");
+  const filePath = path10.resolve(opts.from);
   let raw;
   try {
-    raw = await fs10.readFile(filePath, "utf8");
+    raw = await fs11.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -8552,13 +9534,13 @@ async function wordpressSetSchema(project, body) {
   printManualAssist(`Schema update for "${body.slug}"`, result);
 }
 async function wordpressSchemaDeploy(project, opts) {
-  const fs10 = await import("fs/promises");
-  const path9 = await import("path");
+  const fs11 = await import("fs/promises");
+  const path10 = await import("path");
   const yaml = await import("yaml").catch(() => null);
-  const filePath = path9.resolve(opts.profile);
+  const filePath = path10.resolve(opts.profile);
   let raw;
   try {
-    raw = await fs10.readFile(filePath, "utf8");
+    raw = await fs11.readFile(filePath, "utf8");
   } catch {
     throw new CliError({
       code: "FILE_READ_ERROR",
@@ -8663,13 +9645,13 @@ async function wordpressOnboard(project, opts) {
   }
   let profileData;
   if (opts.profile) {
-    const fs10 = await import("fs/promises");
-    const path9 = await import("path");
+    const fs11 = await import("fs/promises");
+    const path10 = await import("path");
     const yaml = await import("yaml").catch(() => null);
-    const filePath = path9.resolve(opts.profile);
+    const filePath = path10.resolve(opts.profile);
     let raw;
     try {
-      raw = await fs10.readFile(filePath, "utf8");
+      raw = await fs11.readFile(filePath, "utf8");
     } catch {
       throw new CliError({
         code: "FILE_READ_ERROR",
@@ -8818,7 +9800,7 @@ function resolveContent(input, command, usage, options) {
   }
   if (contentFile) {
     try {
-      return fs9.readFileSync(contentFile, "utf-8");
+      return fs10.readFileSync(contentFile, "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       throw usageError(`Error: could not read --content-file "${contentFile}": ${message}`, {
@@ -9749,6 +10731,7 @@ var REGISTERED_CLI_COMMANDS = [
   ...BACKLINKS_CLI_COMMANDS,
   ...SYSTEM_CLI_COMMANDS,
   ...PROJECT_CLI_COMMANDS,
+  ...REPORT_CLI_COMMANDS,
   ...KEYWORD_CLI_COMMANDS,
   ...COMPETITOR_CLI_COMMANDS,
   ...SETTINGS_CLI_COMMANDS,
@@ -9772,7 +10755,7 @@ var REGISTERED_CLI_COMMANDS = [
 
 // src/cli.ts
 import { createRequire as createRequire2 } from "module";
-var USAGE2 = `
+var USAGE3 = `
 canonry \u2014 AEO monitoring CLI
 
 Usage:  canonry <command> [options]
@@ -9833,7 +10816,7 @@ function extractFormat(cmdArgs) {
 }
 async function runCli(args = process.argv.slice(2)) {
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-    console.log(USAGE2);
+    console.log(USAGE3);
     return 0;
   }
   if (args.includes("--version") || args.includes("-v")) {