@ainyc/canonry 2.10.1 → 2.12.0

package/dist/{chunk-SZSWQG3J.js → chunk-FCYNFM4B.js}

@@ -6,6 +6,7 @@ import {
   ApiClient,
   AppError,
   CcReleaseSyncStatuses,
+  CitationStates,
   MemorySources,
   RunKinds,
   RunStatuses,
@@ -54,7 +55,7 @@ import {
   visibilityStateFromAnswerMentioned,
   windowCutoff,
   wordpressEnvSchema
-} from "./chunk-KWQCQMPY.js";
+} from "./chunk-PLI7EOPM.js";
 import {
   IntelligenceService,
   agentMemory,
@@ -65,6 +66,10 @@ import {
   backlinkSummaries,
   bingCoverageSnapshots,
   bingUrlInspections,
+  buildContentGapRows,
+  buildContentSourceRows,
+  buildContentTargetRows,
+  buildInventory,
   ccReleaseSyncs,
   competitors,
   createLogger,
@@ -79,6 +84,7 @@ import {
   gscUrlInspections,
   healthSnapshots,
   insights,
+  isBlogShapedQuery,
   keywords,
   notifications,
   parseJsonColumn,
@@ -87,7 +93,7 @@ import {
   runs,
   schedules,
   usageCounters
-} from "./chunk-PYHANJ3B.js";
+} from "./chunk-UM6RDSRJ.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -167,7 +173,7 @@ import crypto28 from "crypto";
 import fs12 from "fs";
 import path14 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { eq as eq30 } from "drizzle-orm";
+import { eq as eq32 } from "drizzle-orm";
 import Fastify from "fastify";
 
 // ../api-routes/src/auth.ts
@@ -2347,6 +2353,659 @@ async function intelligenceRoutes(app) {
   });
 }
 
+// ../api-routes/src/composites.ts
+import { eq as eq12, and as and3, desc as desc5, sql as sql3, like, or as or2 } from "drizzle-orm";
+var TOP_INSIGHT_LIMIT = 5;
+var SEARCH_HIT_HARD_LIMIT = 50;
+var SEARCH_SNIPPET_RADIUS = 80;
+async function compositeRoutes(app) {
+  app.get("/projects/:name/overview", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const totalRunsRow = app.db.select({ count: sql3`count(*)` }).from(runs).where(eq12(runs.projectId, project.id)).get();
+    const totalRuns = totalRunsRow?.count ?? 0;
+    const recentRuns = app.db.select().from(runs).where(eq12(runs.projectId, project.id)).orderBy(desc5(runs.createdAt)).limit(2).all();
+    const [latestRunRow, previousRunRow] = recentRuns;
+    const latestRun = latestRunRow ? { totalRuns, run: summarizeRun(latestRunRow) } : { totalRuns: 0, run: null };
+    const healthRow = app.db.select().from(healthSnapshots).where(eq12(healthSnapshots.projectId, project.id)).orderBy(desc5(healthSnapshots.createdAt)).limit(1).get();
+    const health = healthRow ? mapHealthRow2(healthRow) : null;
+    const insightRows = app.db.select().from(insights).where(eq12(insights.projectId, project.id)).orderBy(desc5(insights.createdAt)).all();
+    const topInsights = insightRows.filter((row) => !row.dismissed).slice(0, TOP_INSIGHT_LIMIT).map(mapInsightRow2);
+    const { keywordCounts, providers } = summarizeLatestRun(app, latestRunRow ?? null);
+    const transitions = summarizeTransitions(app, latestRunRow ?? null, previousRunRow ?? null);
+    const result = {
+      project: formatProject2(project),
+      latestRun,
+      health,
+      topInsights,
+      keywordCounts,
+      providers,
+      transitions
+    };
+    return reply.send(result);
+  });
+  app.get("/projects/:name/search", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const rawQuery = (request.query.q ?? "").trim();
+    if (rawQuery.length < 2) {
+      throw validationError('"q" must be at least 2 characters');
+    }
+    const limit = clampSearchLimit(request.query.limit);
+    const escaped = escapeLikePattern(rawQuery);
+    const pattern = `%${escaped}%`;
+    const snapshotMatches = app.db.select({
+      id: querySnapshots.id,
+      runId: querySnapshots.runId,
+      keywordId: querySnapshots.keywordId,
+      keywordText: keywords.keyword,
+      provider: querySnapshots.provider,
+      model: querySnapshots.model,
+      citationState: querySnapshots.citationState,
+      answerText: querySnapshots.answerText,
+      citedDomains: querySnapshots.citedDomains,
+      rawResponse: querySnapshots.rawResponse,
+      createdAt: querySnapshots.createdAt
+    }).from(querySnapshots).innerJoin(keywords, eq12(querySnapshots.keywordId, keywords.id)).where(
+      and3(
+        eq12(keywords.projectId, project.id),
+        or2(
+          sql3`${querySnapshots.answerText} LIKE ${pattern} ESCAPE '\\'`,
+          sql3`${querySnapshots.citedDomains} LIKE ${pattern} ESCAPE '\\'`,
+          sql3`${querySnapshots.rawResponse} LIKE ${pattern} ESCAPE '\\'`,
+          like(keywords.keyword, pattern)
+        )
+      )
+    ).orderBy(desc5(querySnapshots.createdAt)).limit(limit + 1).all();
+    const insightMatches = app.db.select().from(insights).where(
+      and3(
+        eq12(insights.projectId, project.id),
+        or2(
+          like(insights.title, pattern),
+          like(insights.keyword, pattern),
+          sql3`${insights.recommendation} LIKE ${pattern} ESCAPE '\\'`,
+          sql3`${insights.cause} LIKE ${pattern} ESCAPE '\\'`
+        )
+      )
+    ).orderBy(desc5(insights.createdAt)).limit(limit + 1).all();
+    const hits = [];
+    for (const row of snapshotMatches) {
+      hits.push(buildSnapshotHit(row, rawQuery));
+    }
+    for (const row of insightMatches) {
+      hits.push(buildInsightHit(row, rawQuery));
+    }
+    hits.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    const truncated = hits.length > limit;
+    const trimmed = truncated ? hits.slice(0, limit) : hits;
+    const response = {
+      query: rawQuery,
+      totalHits: trimmed.length,
+      truncated,
+      hits: trimmed
+    };
+    return reply.send(response);
+  });
+}
+function clampSearchLimit(raw) {
+  if (!raw) return 25;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed)) return 25;
+  if (parsed < 1) return 1;
+  if (parsed > SEARCH_HIT_HARD_LIMIT) return SEARCH_HIT_HARD_LIMIT;
+  return parsed;
+}
+function escapeLikePattern(value) {
+  return value.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+function summarizeRun(run) {
+  return {
+    id: run.id,
+    projectId: run.projectId,
+    kind: run.kind,
+    status: run.status,
+    trigger: run.trigger,
+    location: run.location,
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    error: parseRunError(run.error),
+    createdAt: run.createdAt
+  };
+}
+function summarizeLatestRun(app, run) {
+  const empty = {
+    keywordCounts: { totalKeywords: 0, citedKeywords: 0, notCitedKeywords: 0, citedRate: 0 },
+    providers: []
+  };
+  if (!run) return empty;
+  const rows = app.db.select({
+    keywordId: querySnapshots.keywordId,
+    provider: querySnapshots.provider,
+    citationState: querySnapshots.citationState
+  }).from(querySnapshots).where(eq12(querySnapshots.runId, run.id)).all();
+  if (rows.length === 0) return empty;
+  const perKeyword = /* @__PURE__ */ new Map();
+  const perProvider = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const cited = row.citationState === "cited";
+    if (!perKeyword.has(row.keywordId) || cited) {
+      perKeyword.set(row.keywordId, cited);
+    }
+    const bucket = perProvider.get(row.provider) ?? { cited: 0, total: 0 };
+    bucket.total += 1;
+    if (cited) bucket.cited += 1;
+    perProvider.set(row.provider, bucket);
+  }
+  const totalKeywords = perKeyword.size;
+  let citedKeywords = 0;
+  for (const wasCited of perKeyword.values()) {
+    if (wasCited) citedKeywords += 1;
+  }
+  const notCitedKeywords = totalKeywords - citedKeywords;
+  const citedRate = totalKeywords === 0 ? 0 : Number((citedKeywords / totalKeywords).toFixed(4));
+  const providers = [...perProvider.entries()].map(([provider, { cited, total }]) => ({
+    provider,
+    cited,
+    total,
+    citedRate: total === 0 ? 0 : Number((cited / total).toFixed(4))
+  })).sort((a, b) => a.provider.localeCompare(b.provider));
+  return {
+    keywordCounts: { totalKeywords, citedKeywords, notCitedKeywords, citedRate },
+    providers
+  };
+}
+function summarizeTransitions(app, latest, previous) {
+  const empty = { since: null, gained: 0, lost: 0, emerging: 0 };
+  if (!latest || !previous) return empty;
+  const fetchCited = (runId) => {
+    const rows = app.db.select({
+      keywordId: querySnapshots.keywordId,
+      citationState: querySnapshots.citationState
+    }).from(querySnapshots).where(eq12(querySnapshots.runId, runId)).all();
+    const map = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const cited = row.citationState === "cited";
+      if (!map.has(row.keywordId) || cited) map.set(row.keywordId, cited);
+    }
+    return map;
+  };
+  const latestMap = fetchCited(latest.id);
+  const previousMap = fetchCited(previous.id);
+  let gained = 0;
+  let lost = 0;
+  let emerging = 0;
+  for (const [keywordId, latestCited] of latestMap) {
+    const previousCited = previousMap.get(keywordId);
+    if (previousCited === void 0) {
+      if (latestCited) emerging += 1;
+      continue;
+    }
+    if (latestCited && !previousCited) gained += 1;
+    else if (!latestCited && previousCited) lost += 1;
+  }
+  return { since: previous.createdAt, gained, lost, emerging };
+}
+function mapInsightRow2(r) {
+  return {
+    id: r.id,
+    projectId: r.projectId,
+    runId: r.runId ?? null,
+    type: r.type,
+    severity: r.severity,
+    title: r.title,
+    keyword: r.keyword,
+    provider: r.provider,
+    recommendation: parseJsonColumn(r.recommendation, void 0),
+    cause: parseJsonColumn(r.cause, void 0),
+    dismissed: r.dismissed,
+    createdAt: r.createdAt
+  };
+}
+function mapHealthRow2(r) {
+  return {
+    id: r.id,
+    projectId: r.projectId,
+    runId: r.runId ?? null,
+    overallCitedRate: Number(r.overallCitedRate),
+    totalPairs: r.totalPairs,
+    citedPairs: r.citedPairs,
+    providerBreakdown: parseJsonColumn(r.providerBreakdown, {}),
+    createdAt: r.createdAt,
+    status: "ready"
+  };
+}
+function formatProject2(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    displayName: row.displayName,
+    canonicalDomain: row.canonicalDomain,
+    ownedDomains: parseJsonColumn(row.ownedDomains, []),
+    country: row.country,
+    language: row.language,
+    tags: parseJsonColumn(row.tags, []),
+    labels: parseJsonColumn(row.labels, {}),
+    locations: parseJsonColumn(row.locations, []),
+    defaultLocation: row.defaultLocation,
+    autoExtractBacklinks: row.autoExtractBacklinks === 1,
+    configSource: row.configSource,
+    configRevision: row.configRevision,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function buildSnapshotHit(row, query) {
+  const lower = query.toLowerCase();
+  const keyword = row.keywordText ?? "";
+  const answer = row.answerText ?? "";
+  const cited = row.citedDomains;
+  const raw = row.rawResponse ?? "";
+  let matchedField;
+  let snippet;
+  if (answer.toLowerCase().includes(lower)) {
+    matchedField = "answerText";
+    snippet = makeSnippet(answer, query);
+  } else if (cited.toLowerCase().includes(lower)) {
+    matchedField = "citedDomains";
+    snippet = makeSnippet(cited, query);
+  } else if (raw.toLowerCase().includes(lower)) {
+    matchedField = "searchQueries";
+    snippet = makeSnippet(raw, query);
+  } else {
+    matchedField = "keyword";
+    snippet = keyword;
+  }
+  return {
+    kind: "snapshot",
+    id: row.id,
+    runId: row.runId,
+    keyword,
+    provider: row.provider,
+    model: row.model,
+    citationState: row.citationState,
+    matchedField,
+    snippet,
+    createdAt: row.createdAt
+  };
+}
+function buildInsightHit(row, query) {
+  const lower = query.toLowerCase();
+  const recommendation = row.recommendation ?? "";
+  const cause = row.cause ?? "";
+  let matchedField;
+  let snippet;
+  if (row.title.toLowerCase().includes(lower)) {
+    matchedField = "title";
+    snippet = makeSnippet(row.title, query);
+  } else if (row.keyword.toLowerCase().includes(lower)) {
+    matchedField = "keyword";
+    snippet = row.keyword;
+  } else if (recommendation.toLowerCase().includes(lower)) {
+    matchedField = "recommendation";
+    snippet = makeSnippet(recommendation, query);
+  } else {
+    matchedField = "cause";
+    snippet = makeSnippet(cause, query);
+  }
+  return {
+    kind: "insight",
+    id: row.id,
+    runId: row.runId ?? null,
+    type: row.type,
+    severity: row.severity,
+    title: row.title,
+    keyword: row.keyword,
+    provider: row.provider,
+    matchedField,
+    snippet,
+    dismissed: row.dismissed,
+    createdAt: row.createdAt
+  };
+}
+function makeSnippet(text, query) {
+  if (!text) return "";
+  const needle = query.toLowerCase();
+  const haystack = text.toLowerCase();
+  const idx = haystack.indexOf(needle);
+  if (idx < 0) {
+    return text.length <= SEARCH_SNIPPET_RADIUS * 2 ? text : `${text.slice(0, SEARCH_SNIPPET_RADIUS * 2)}\u2026`;
+  }
+  const start = Math.max(0, idx - SEARCH_SNIPPET_RADIUS);
+  const end = Math.min(text.length, idx + query.length + SEARCH_SNIPPET_RADIUS);
+  const prefix = start === 0 ? "" : "\u2026";
+  const suffix = end === text.length ? "" : "\u2026";
+  return `${prefix}${text.slice(start, end)}${suffix}`;
+}
+
+// ../api-routes/src/content-data.ts
+import { and as and4, eq as eq13, desc as desc6, inArray as inArray3 } from "drizzle-orm";
+var RECENT_RUNS_WINDOW = 5;
+function loadOrchestratorInput(db, project) {
+  const projectId = project.id;
+  const ownDomain = normalizeDomain(project.canonicalDomain);
+  const ownedDomains = parseJsonColumn(project.ownedDomains, []);
+  const ourDomains = /* @__PURE__ */ new Set([ownDomain, ...ownedDomains.map(normalizeDomain)]);
+  const trackedKeywords = listKeywords(db, projectId);
+  const candidateQueryStrings = trackedKeywords.filter(isBlogShapedQuery);
+  const trackedCompetitors = listCompetitorDomains(db, projectId).map(normalizeDomain);
+  const competitorSet = new Set(trackedCompetitors);
+  const recentRunIds = listRecentAnswerVisibilityRunIds(db, projectId, RECENT_RUNS_WINDOW);
+  const latestRunId = recentRunIds[0] ?? "";
+  const latestRunTimestamp = latestRunId ? lookupRunTimestamp(db, latestRunId) : "";
+  const candidateQueries = buildCandidateQueries({
+    db,
+    projectId,
+    candidateQueryStrings,
+    recentRunIds,
+    latestRunId,
+    ourDomains,
+    competitorSet
+  });
+  const inventory = buildInventory({
+    gscPages: listGscPagesForProject(db, projectId),
+    ga4LandingPages: listGa4LandingPagesForProject(db, projectId),
+    sitemapUrls: [],
+    wpPosts: []
+  });
+  const gaTrafficByPage = buildGaTrafficByPage(db, projectId);
+  const totalAiReferralSessions = sumAiReferralSessions(db, projectId);
+  return {
+    projectId,
+    ownDomain,
+    competitors: trackedCompetitors,
+    candidateQueries,
+    inventory,
+    wpSchemaAudit: /* @__PURE__ */ new Map(),
+    gaTrafficByPage,
+    totalAiReferralSessions,
+    latestRunId,
+    latestRunTimestamp,
+    inProgressActions: /* @__PURE__ */ new Map()
+  };
+}
+function listKeywords(db, projectId) {
+  const rows = db.select({ text: keywords.keyword }).from(keywords).where(eq13(keywords.projectId, projectId)).all();
+  return rows.map((r) => r.text);
+}
+function listCompetitorDomains(db, projectId) {
+  const rows = db.select({ domain: competitors.domain }).from(competitors).where(eq13(competitors.projectId, projectId)).all();
+  return rows.map((r) => r.domain);
+}
+function listRecentAnswerVisibilityRunIds(db, projectId, limit) {
+  const rows = db.select({ id: runs.id }).from(runs).where(
+    and4(
+      eq13(runs.projectId, projectId),
+      eq13(runs.kind, RunKinds["answer-visibility"]),
+      // Queued/running/failed/cancelled runs may have partial or no
+      // snapshots; including them risks pointing latestRunId at a run with
+      // no usable evidence.
+      inArray3(runs.status, [RunStatuses.completed, RunStatuses.partial])
+    )
+  ).orderBy(desc6(runs.createdAt)).limit(limit).all();
+  return rows.map((r) => r.id);
+}
+function lookupRunTimestamp(db, runId) {
+  const row = db.select({ createdAt: runs.createdAt }).from(runs).where(eq13(runs.id, runId)).get();
+  return row?.createdAt ?? "";
+}
+function listGscPagesForProject(db, projectId) {
+  const rows = db.selectDistinct({ page: gscSearchData.page }).from(gscSearchData).where(eq13(gscSearchData.projectId, projectId)).all();
+  return rows.map((r) => r.page);
+}
+function listGa4LandingPagesForProject(db, projectId) {
+  const rows = db.selectDistinct({ landingPage: gaTrafficSnapshots.landingPage }).from(gaTrafficSnapshots).where(eq13(gaTrafficSnapshots.projectId, projectId)).all();
+  return rows.map((r) => r.landingPage);
+}
+function buildGaTrafficByPage(db, projectId) {
+  const rows = db.select({
+    landingPage: gaTrafficSnapshots.landingPage,
+    sessions: gaTrafficSnapshots.sessions
+  }).from(gaTrafficSnapshots).where(eq13(gaTrafficSnapshots.projectId, projectId)).all();
+  const map = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const path15 = extractPath(row.landingPage);
+    if (!path15) continue;
+    map.set(path15, (map.get(path15) ?? 0) + (row.sessions ?? 0));
+  }
+  return map;
+}
+function sumAiReferralSessions(db, projectId) {
+  const rows = db.select({ sessions: gaAiReferrals.sessions }).from(gaAiReferrals).where(eq13(gaAiReferrals.projectId, projectId)).all();
+  return rows.reduce((acc, r) => acc + (r.sessions ?? 0), 0);
+}
+function buildCandidateQueries(opts) {
+  if (opts.candidateQueryStrings.length === 0 || opts.recentRunIds.length === 0) {
+    return opts.candidateQueryStrings.map((query) => emptyCandidate(query));
+  }
+  const keywordRows = opts.db.select({ id: keywords.id, text: keywords.keyword }).from(keywords).where(eq13(keywords.projectId, opts.projectId)).all();
+  const keywordIdByText = new Map(keywordRows.map((r) => [r.text, r.id]));
+  const candidateKeywordIds = opts.candidateQueryStrings.map((q) => keywordIdByText.get(q)).filter((id) => Boolean(id));
+  const snapshotRows = opts.db.select().from(querySnapshots).where(inArray3(querySnapshots.runId, opts.recentRunIds)).all().filter((r) => candidateKeywordIds.includes(r.keywordId));
+  const snapshotsByKeyword = /* @__PURE__ */ new Map();
+  for (const row of snapshotRows) {
+    const list = snapshotsByKeyword.get(row.keywordId) ?? [];
+    list.push(row);
+    snapshotsByKeyword.set(row.keywordId, list);
+  }
+  const gscRows = opts.db.select().from(gscSearchData).where(eq13(gscSearchData.projectId, opts.projectId)).all();
+  const gscByQuery = aggregateGscByQuery(gscRows);
+  return opts.candidateQueryStrings.map((query) => {
+    const keywordId = keywordIdByText.get(query);
+    const snaps = keywordId ? snapshotsByKeyword.get(keywordId) ?? [] : [];
+    const gsc = gscByQuery.get(query) ?? null;
+    return aggregateCandidate({
+      query,
+      snapshots: snaps,
+      gsc,
+      ourDomains: opts.ourDomains,
+      competitorSet: opts.competitorSet,
+      latestRunId: opts.latestRunId
+    });
+  });
+}
+function aggregateGscByQuery(rows) {
+  const byQuery = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const existing = byQuery.get(r.query);
+    const candidate = {
+      // GSC stores `page` as a full URL for url-prefix properties; normalize to
+      // a path so it can be joined against `gaTrafficByPage` (which is keyed by
+      // path) and so `ourBestPage.url` / `targetRef` stay consistent regardless
+      // of whether the page is sourced from GSC or from inventory.
+      page: extractPath(r.page),
+      position: Number(r.position) || 0,
+      impressions: r.impressions,
+      clicks: r.clicks,
+      ctr: Number(r.ctr) || 0
+    };
+    if (!existing) {
+      byQuery.set(r.query, candidate);
+      continue;
+    }
+    if (candidate.impressions > existing.impressions) {
+      byQuery.set(r.query, candidate);
+    }
+  }
+  return byQuery;
+}
+function aggregateCandidate(opts) {
+  const totalSnaps = opts.snapshots.length;
+  if (totalSnaps === 0) {
+    return {
+      ...emptyCandidate(opts.query),
+      gscPage: opts.gsc?.page ?? null,
+      gscPosition: opts.gsc ? opts.gsc.position : null,
+      gscImpressions: opts.gsc?.impressions ?? 0,
+      gscClicks: opts.gsc?.clicks ?? 0,
+      gscCtr: opts.gsc?.ctr ?? 0
+    };
+  }
+  const citedCount = opts.snapshots.filter((s) => s.citationState === CitationStates.cited).length;
+  const ourCitedRate = citedCount / totalSnaps;
+  const recentMissRate = 1 - ourCitedRate;
+  const competitorTally = /* @__PURE__ */ new Map();
+  const competitorGroundingTally = /* @__PURE__ */ new Map();
+  const ourGroundingTally = /* @__PURE__ */ new Map();
+  let ourCitedInLatestRun = false;
+  for (const snap of opts.snapshots) {
+    const isLatestRun = snap.runId === opts.latestRunId;
+    const competitorOverlap = parseJsonColumn(snap.competitorOverlap, []);
+    for (const domain of competitorOverlap) {
+      const normalized = normalizeDomain(domain);
+      if (!opts.competitorSet.has(normalized)) continue;
+      competitorTally.set(normalized, (competitorTally.get(normalized) ?? 0) + 1);
+    }
+    const grounding = extractGroundingSources(snap.rawResponse);
+    for (const g of grounding) {
+      const domain = normalizeDomain(extractHostFromUri(g.uri));
+      if (!domain) continue;
+      if (opts.ourDomains.has(domain)) {
+        if (isLatestRun) ourCitedInLatestRun = true;
+        recordGroundingHit(ourGroundingTally, g, domain, snap.provider);
+        continue;
+      }
+      if (!opts.competitorSet.has(domain)) continue;
+      recordGroundingHit(competitorGroundingTally, g, domain, snap.provider);
+    }
+  }
+  return {
+    query: opts.query,
+    gscPage: opts.gsc?.page ?? null,
+    gscPosition: opts.gsc ? opts.gsc.position : null,
+    gscImpressions: opts.gsc?.impressions ?? 0,
+    gscClicks: opts.gsc?.clicks ?? 0,
+    gscCtr: opts.gsc?.ctr ?? 0,
+    ourCitedRate,
+    ourCitedInLatestRun,
+    competitorDomains: Array.from(competitorTally.keys()),
+    competitorCitationCount: Array.from(competitorTally.values()).reduce((a, b) => a + b, 0),
+    recentMissRate,
+    ourGroundingUrls: Array.from(ourGroundingTally.values()),
+    competitorGroundingUrls: Array.from(competitorGroundingTally.values()),
+    runsOfHistory: new Set(opts.snapshots.map((s) => s.runId)).size
+  };
+}
+function recordGroundingHit(tally, g, domain, provider) {
+  const existing = tally.get(g.uri);
+  if (existing) {
+    existing.citationCount += 1;
+    if (provider && !existing.providers.includes(provider)) {
+      existing.providers.push(provider);
+    }
+    return;
+  }
+  tally.set(g.uri, {
+    uri: g.uri,
+    title: g.title,
+    domain,
+    citationCount: 1,
+    providers: provider ? [provider] : []
+  });
+}
+function emptyCandidate(query) {
+  return {
+    query,
+    gscPage: null,
+    gscPosition: null,
+    gscImpressions: 0,
+    gscClicks: 0,
+    gscCtr: 0,
+    ourCitedRate: 0,
+    ourCitedInLatestRun: false,
+    competitorDomains: [],
+    competitorCitationCount: 0,
+    recentMissRate: 0,
+    ourGroundingUrls: [],
+    competitorGroundingUrls: [],
+    runsOfHistory: 0
+  };
+}
+function extractGroundingSources(rawResponse) {
+  if (!rawResponse) return [];
+  try {
+    const parsed = JSON.parse(rawResponse);
+    if (parsed && typeof parsed === "object" && "groundingSources" in parsed) {
+      const grounding = parsed.groundingSources;
+      if (Array.isArray(grounding)) {
+        return grounding.filter(
+          (g) => typeof g === "object" && g !== null && typeof g.uri === "string"
+        ).map((g) => ({ uri: g.uri, title: g.title ?? "" }));
+      }
+    }
+  } catch {
+  }
+  return [];
+}
+function extractHostFromUri(uri) {
+  try {
+    return new URL(uri).hostname;
+  } catch {
+    return "";
+  }
+}
+function normalizeDomain(domain) {
+  return domain.toLowerCase().replace(/^https?:\/\//, "").replace(/^www\./, "").replace(/\/$/, "");
+}
+function extractPath(url) {
+  if (!url) return "";
+  const match = /^https?:\/\/[^/]+(.*)$/.exec(url.trim());
+  const path15 = match ? match[1] : url.trim();
+  const stripped = path15.replace(/\/+$/, "");
+  return stripped || "/";
+}
+
+// ../api-routes/src/content.ts
+async function contentRoutes(app) {
+  app.get("/projects/:name/content/targets", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const includeInProgress = request.query["include-in-progress"] === "true";
+    const limit = parseLimitParam(request.query.limit);
+    const input = loadOrchestratorInput(app.db, project);
+    let rows = buildContentTargetRows(input);
+    if (!includeInProgress) {
+      rows = rows.filter((r) => r.existingAction === null);
+    }
+    if (limit !== void 0) {
+      rows = rows.slice(0, limit);
+    }
+    const response = {
+      targets: rows,
+      contextMetrics: {
+        totalAiReferralSessions: input.totalAiReferralSessions,
+        latestRunId: input.latestRunId,
+        runTimestamp: input.latestRunTimestamp
+      }
+    };
+    return response;
+  });
+  app.get("/projects/:name/content/sources", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const input = loadOrchestratorInput(app.db, project);
+    const rows = buildContentSourceRows(input);
+    const response = {
+      sources: rows,
+      latestRunId: input.latestRunId
+    };
+    return response;
+  });
+  app.get("/projects/:name/content/gaps", async (request) => {
+    const project = resolveProject(app.db, request.params.name);
+    const input = loadOrchestratorInput(app.db, project);
+    const rows = buildContentGapRows(input);
+    const response = {
+      gaps: rows,
+      latestRunId: input.latestRunId
+    };
+    return response;
+  });
+}
+function parseLimitParam(raw) {
+  if (raw === void 0) return void 0;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0 || !Number.isInteger(parsed)) {
+    throw validationError('"limit" must be a non-negative integer');
+  }
+  return parsed;
+}
+
 // ../api-routes/src/openapi.ts
 var stringSchema = { type: "string" };
 var booleanSchema = { type: "boolean" };
@@ -4573,6 +5232,77 @@ var routeCatalog = [
       404: { description: "Project not found." }
     }
   },
+  // Content opportunity engine
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/content/targets",
+    summary: "Ranked, action-typed content opportunities",
+    description: "Returns the canonical opportunity list. Each row is `{query, action, ourBestPage?, winningCompetitor?, score, scoreBreakdown, drivers[], demandSource, actionConfidence, existingAction?}`. Hides rows with in-progress actions by default; pass `?include-in-progress=true` to include them annotated.",
+    tags: ["content"],
+    parameters: [
+      nameParameter,
+      { name: "limit", in: "query", description: "Max rows returned.", schema: stringSchema },
+      { name: "include-in-progress", in: "query", description: "Include rows with in-flight tracked actions.", schema: stringSchema }
+    ],
+    responses: {
+      200: { description: "Targets returned." },
+      400: { description: "Invalid limit." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/content/sources",
+    summary: "URL-level competitive grounding-source map per query",
+    description: "Returns one row per blog-shaped query containing the grounding URLs the LLM cited. Distinguishes our domain (isOurDomain) from competitor URLs (isCompetitor). Pure DB read \u2014 canonry surfaces URLs but never fetches them.",
+    tags: ["content"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Sources returned." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/content/gaps",
+    summary: "Queries where competitors are cited but you are not",
+    description: "Returns gap rows ranked by miss rate then by competitor count. Excludes queries with no competitor citations and queries where our cited rate is 100%.",
+    tags: ["content"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Gaps returned." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/overview",
+    summary: "Get a composite overview of project health",
+    description: 'Bundles project info, latest run, top undismissed insights, the latest health snapshot, keyword cited rate, per-provider breakdown, and transitions vs. the previous run. Designed for the "how is project X doing?" question so agents can answer in one call.',
+    tags: ["intelligence"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Overview returned." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/search",
+    summary: "Search query snapshots and insights for text",
+    description: "Returns the most recent snapshots and insights whose answer text, cited domains, raw response, or insight title/keyword/recommendation/cause matches the query. Use to find anything mentioning a competitor, term, or URL without paginating snapshots.",
+    tags: ["intelligence"],
+    parameters: [
+      nameParameter,
+      { name: "q", in: "query", required: true, description: "Search term (>= 2 chars).", schema: stringSchema },
+      { name: "limit", in: "query", description: "Max combined hits (1-50, default 25).", schema: stringSchema }
+    ],
+    responses: {
+      200: { description: "Search hits returned." },
+      400: { description: "Query string missing or too short." },
+      404: { description: "Project not found." }
+    }
+  },
   {
     method: "get",
     path: "/api/v1/backlinks/status",
@@ -5031,7 +5761,7 @@ async function telemetryRoutes(app, opts) {
 
 // ../api-routes/src/schedules.ts
 import crypto11 from "crypto";
-import { eq as eq12 } from "drizzle-orm";
+import { eq as eq14 } from "drizzle-orm";
 async function scheduleRoutes(app, opts) {
   app.put("/projects/:name/schedule", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -5074,7 +5804,7 @@ async function scheduleRoutes(app, opts) {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const enabledInt = enabled === false ? 0 : 1;
-    const existing = app.db.select().from(schedules).where(eq12(schedules.projectId, project.id)).get();
+    const existing = app.db.select().from(schedules).where(eq14(schedules.projectId, project.id)).get();
     if (existing) {
       app.db.update(schedules).set({
         cronExpr,
@@ -5083,7 +5813,7 @@ async function scheduleRoutes(app, opts) {
         providers: JSON.stringify(providers),
         enabled: enabledInt,
         updatedAt: now
-      }).where(eq12(schedules.id, existing.id)).run();
+      }).where(eq14(schedules.id, existing.id)).run();
     } else {
       app.db.insert(schedules).values({
         id: crypto11.randomUUID(),
@@ -5105,12 +5835,12 @@ async function scheduleRoutes(app, opts) {
       diff: { cronExpr, preset, timezone, providers }
     });
     opts.onScheduleUpdated?.("upsert", project.id);
-    const schedule = app.db.select().from(schedules).where(eq12(schedules.projectId, project.id)).get();
+    const schedule = app.db.select().from(schedules).where(eq14(schedules.projectId, project.id)).get();
     return reply.status(existing ? 200 : 201).send(formatSchedule(schedule));
   });
   app.get("/projects/:name/schedule", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const schedule = app.db.select().from(schedules).where(eq12(schedules.projectId, project.id)).get();
+    const schedule = app.db.select().from(schedules).where(eq14(schedules.projectId, project.id)).get();
     if (!schedule) {
       throw notFound("Schedule", request.params.name);
     }
@@ -5118,11 +5848,11 @@ async function scheduleRoutes(app, opts) {
   });
   app.delete("/projects/:name/schedule", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const schedule = app.db.select().from(schedules).where(eq12(schedules.projectId, project.id)).get();
+    const schedule = app.db.select().from(schedules).where(eq14(schedules.projectId, project.id)).get();
     if (!schedule) {
       throw notFound("Schedule", request.params.name);
     }
-    app.db.delete(schedules).where(eq12(schedules.id, schedule.id)).run();
+    app.db.delete(schedules).where(eq14(schedules.id, schedule.id)).run();
     writeAuditLog(app.db, {
       projectId: project.id,
       actor: "api",
@@ -5152,7 +5882,7 @@ function formatSchedule(row) {
 
 // ../api-routes/src/notifications.ts
 import crypto12 from "crypto";
-import { eq as eq13 } from "drizzle-orm";
+import { eq as eq15 } from "drizzle-orm";
 var VALID_EVENTS = ["citation.lost", "citation.gained", "run.completed", "run.failed", "insight.critical", "insight.high"];
 async function notificationRoutes(app) {
   app.get("/notifications/events", async (_request, reply) => {
@@ -5191,22 +5921,22 @@ async function notificationRoutes(app) {
       diff: { channel, ...redactNotificationUrl(url), events }
     });
     return reply.status(201).send({
-      ...formatNotification(app.db.select().from(notifications).where(eq13(notifications.id, id)).get()),
+      ...formatNotification(app.db.select().from(notifications).where(eq15(notifications.id, id)).get()),
       webhookSecret
     });
   });
   app.get("/projects/:name/notifications", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const rows = app.db.select().from(notifications).where(eq13(notifications.projectId, project.id)).all();
+    const rows = app.db.select().from(notifications).where(eq15(notifications.projectId, project.id)).all();
     return reply.send(rows.map(formatNotification));
   });
   app.delete("/projects/:name/notifications/:id", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const notification = app.db.select().from(notifications).where(eq13(notifications.id, request.params.id)).get();
+    const notification = app.db.select().from(notifications).where(eq15(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
       throw notFound("Notification", request.params.id);
     }
-    app.db.delete(notifications).where(eq13(notifications.id, notification.id)).run();
+    app.db.delete(notifications).where(eq15(notifications.id, notification.id)).run();
     writeAuditLog(app.db, {
       projectId: project.id,
       actor: "api",
@@ -5218,7 +5948,7 @@ async function notificationRoutes(app) {
   });
   app.post("/projects/:name/notifications/:id/test", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const notification = app.db.select().from(notifications).where(eq13(notifications.id, request.params.id)).get();
+    const notification = app.db.select().from(notifications).where(eq15(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
       throw notFound("Notification", request.params.id);
     }
@@ -5271,7 +6001,7 @@ function formatNotification(row) {
 
 // ../api-routes/src/google.ts
 import crypto14 from "crypto";
-import { eq as eq14, and as and3, desc as desc5, sql as sql3 } from "drizzle-orm";
+import { eq as eq16, and as and5, desc as desc7, sql as sql4 } from "drizzle-orm";
 
 // ../integration-google/src/constants.ts
 var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
@@ -6375,20 +7105,20 @@ async function googleRoutes(app, opts) {
     if (opts.onGscSyncRequested) {
       opts.onGscSyncRequested(runId, project.id, { days, full });
     }
-    const run = app.db.select().from(runs).where(eq14(runs.id, runId)).get();
+    const run = app.db.select().from(runs).where(eq16(runs.id, runId)).get();
     return run;
   });
   app.get("/projects/:name/google/gsc/performance", async (request) => {
     const project = resolveProject(app.db, request.params.name);
     const { startDate, endDate, query, page, limit } = request.query;
     const cutoffDate = !startDate ? windowCutoff(parseWindow(request.query.window))?.slice(0, 10) ?? null : null;
-    const conditions = [eq14(gscSearchData.projectId, project.id)];
-    if (startDate) conditions.push(sql3`${gscSearchData.date} >= ${startDate}`);
-    else if (cutoffDate) conditions.push(sql3`${gscSearchData.date} >= ${cutoffDate}`);
-    if (endDate) conditions.push(sql3`${gscSearchData.date} <= ${endDate}`);
-    if (query) conditions.push(sql3`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
-    if (page) conditions.push(sql3`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
-    const rows = app.db.select().from(gscSearchData).where(and3(...conditions)).orderBy(desc5(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
+    const conditions = [eq16(gscSearchData.projectId, project.id)];
+    if (startDate) conditions.push(sql4`${gscSearchData.date} >= ${startDate}`);
+    else if (cutoffDate) conditions.push(sql4`${gscSearchData.date} >= ${cutoffDate}`);
+    if (endDate) conditions.push(sql4`${gscSearchData.date} <= ${endDate}`);
+    if (query) conditions.push(sql4`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
+    if (page) conditions.push(sql4`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
+    const rows = app.db.select().from(gscSearchData).where(and5(...conditions)).orderBy(desc7(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
     return rows.map((r) => ({
       date: r.date,
       query: r.query,
@@ -6460,9 +7190,9 @@ async function googleRoutes(app, opts) {
   app.get("/projects/:name/google/gsc/inspections", async (request) => {
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
-    const conditions = [eq14(gscUrlInspections.projectId, project.id)];
-    if (url) conditions.push(eq14(gscUrlInspections.url, url));
-    const rows = app.db.select().from(gscUrlInspections).where(and3(...conditions)).orderBy(desc5(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
+    const conditions = [eq16(gscUrlInspections.projectId, project.id)];
+    if (url) conditions.push(eq16(gscUrlInspections.url, url));
+    const rows = app.db.select().from(gscUrlInspections).where(and5(...conditions)).orderBy(desc7(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
     return rows.map((r) => ({
       id: r.id,
       url: r.url,
@@ -6481,7 +7211,7 @@ async function googleRoutes(app, opts) {
   });
   app.get("/projects/:name/google/gsc/deindexed", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const allInspections = app.db.select().from(gscUrlInspections).where(eq14(gscUrlInspections.projectId, project.id)).orderBy(desc5(gscUrlInspections.inspectedAt)).all();
+    const allInspections = app.db.select().from(gscUrlInspections).where(eq16(gscUrlInspections.projectId, project.id)).orderBy(desc7(gscUrlInspections.inspectedAt)).all();
     const byUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       const existing = byUrl.get(row.url);
@@ -6509,7 +7239,7 @@ async function googleRoutes(app, opts) {
   });
   app.get("/projects/:name/google/gsc/coverage", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const allInspections = app.db.select().from(gscUrlInspections).where(eq14(gscUrlInspections.projectId, project.id)).orderBy(desc5(gscUrlInspections.inspectedAt)).all();
+    const allInspections = app.db.select().from(gscUrlInspections).where(eq16(gscUrlInspections.projectId, project.id)).orderBy(desc7(gscUrlInspections.inspectedAt)).all();
     const canonicalUrl = (url) => url.replace(/^http:\/\//, "https://");
     const latestByUrl = /* @__PURE__ */ new Map();
     const historyByUrl = /* @__PURE__ */ new Map();
@@ -6606,7 +7336,7 @@ async function googleRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const parsed = parseInt(request.query.limit ?? "90", 10);
     const limit = Number.isNaN(parsed) || parsed <= 0 ? 90 : parsed;
-    const rows = app.db.select().from(gscCoverageSnapshots).where(eq14(gscCoverageSnapshots.projectId, project.id)).orderBy(desc5(gscCoverageSnapshots.date)).limit(limit).all();
+    const rows = app.db.select().from(gscCoverageSnapshots).where(eq16(gscCoverageSnapshots.projectId, project.id)).orderBy(desc7(gscCoverageSnapshots.date)).limit(limit).all();
     return rows.map((r) => ({
       date: r.date,
       indexed: r.indexed,
@@ -6666,7 +7396,7 @@ async function googleRoutes(app, opts) {
     if (opts.onInspectSitemapRequested) {
       opts.onInspectSitemapRequested(runId, project.id, { sitemapUrl });
     }
-    const run = app.db.select().from(runs).where(eq14(runs.id, runId)).get();
+    const run = app.db.select().from(runs).where(eq16(runs.id, runId)).get();
     return { sitemaps, primarySitemapUrl: sitemapUrl, run };
   });
   app.post("/projects/:name/google/gsc/inspect-sitemap", async (request) => {
@@ -6693,7 +7423,7 @@ async function googleRoutes(app, opts) {
     if (opts.onInspectSitemapRequested) {
       opts.onInspectSitemapRequested(runId, project.id, { sitemapUrl: sitemapUrl ?? void 0 });
     }
-    const run = app.db.select().from(runs).where(eq14(runs.id, runId)).get();
+    const run = app.db.select().from(runs).where(eq16(runs.id, runId)).get();
     return run;
   });
   app.put("/projects/:name/google/connections/:type/sitemap", async (request) => {
@@ -6740,7 +7470,7 @@ async function googleRoutes(app, opts) {
     const { accessToken } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
     let urlsToNotify = request.body?.urls ?? [];
     if (request.body?.allUnindexed) {
-      const allInspections = app.db.select().from(gscUrlInspections).where(eq14(gscUrlInspections.projectId, project.id)).orderBy(desc5(gscUrlInspections.inspectedAt)).all();
+      const allInspections = app.db.select().from(gscUrlInspections).where(eq16(gscUrlInspections.projectId, project.id)).orderBy(desc7(gscUrlInspections.inspectedAt)).all();
       const latestByUrl = /* @__PURE__ */ new Map();
       for (const row of allInspections) {
         if (!latestByUrl.has(row.url)) {
@@ -6811,7 +7541,7 @@ async function googleRoutes(app, opts) {
 
 // ../api-routes/src/bing.ts
 import crypto15 from "crypto";
-import { eq as eq15, and as and4, desc as desc6 } from "drizzle-orm";
+import { eq as eq17, and as and6, desc as desc8 } from "drizzle-orm";
 
 // ../integration-bing/src/constants.ts
 var BING_WMT_API_BASE = "https://ssl.bing.com/webmaster/api.svc/json";
@@ -7124,7 +7854,7 @@ async function bingRoutes(app, opts) {
     const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     requireConnection(store, project.canonicalDomain);
-    const allInspections = app.db.select().from(bingUrlInspections).where(eq15(bingUrlInspections.projectId, project.id)).orderBy(desc6(bingUrlInspections.inspectedAt)).all();
+    const allInspections = app.db.select().from(bingUrlInspections).where(eq17(bingUrlInspections.projectId, project.id)).orderBy(desc8(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -7213,7 +7943,7 @@ async function bingRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const parsed = parseInt(request.query.limit ?? "90", 10);
     const limit = Number.isNaN(parsed) || parsed <= 0 ? 90 : parsed;
-    const rows = app.db.select().from(bingCoverageSnapshots).where(eq15(bingCoverageSnapshots.projectId, project.id)).orderBy(desc6(bingCoverageSnapshots.date)).limit(limit).all();
+    const rows = app.db.select().from(bingCoverageSnapshots).where(eq17(bingCoverageSnapshots.projectId, project.id)).orderBy(desc8(bingCoverageSnapshots.date)).limit(limit).all();
     return rows.map((r) => ({
       date: r.date,
       indexed: r.indexed,
@@ -7225,8 +7955,8 @@ async function bingRoutes(app, opts) {
     requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
-    const whereClause = url ? and4(eq15(bingUrlInspections.projectId, project.id), eq15(bingUrlInspections.url, url)) : eq15(bingUrlInspections.projectId, project.id);
-    const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc6(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
+    const whereClause = url ? and6(eq17(bingUrlInspections.projectId, project.id), eq17(bingUrlInspections.url, url)) : eq17(bingUrlInspections.projectId, project.id);
+    const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc8(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
     return filtered.map((r) => ({
       id: r.id,
       url: r.url,
@@ -7315,7 +8045,7 @@ async function bingRoutes(app, opts) {
         anchorCount: result.AnchorCount ?? null,
         discoveryDate
       }).run();
-      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq15(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq17(runs.id, runId)).run();
       return {
         id,
         url,
@@ -7331,7 +8061,7 @@ async function bingRoutes(app, opts) {
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       bingLog("error", "inspect-url.failed", { domain: project.canonicalDomain, url, error: msg });
-      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq15(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq17(runs.id, runId)).run();
       throw e;
     }
   });
@@ -7358,7 +8088,7 @@ async function bingRoutes(app, opts) {
     } else {
       bingLog("warn", "inspect-sitemap.no-callback", { domain: project.canonicalDomain, runId });
     }
-    const run = app.db.select().from(runs).where(eq15(runs.id, runId)).get();
+    const run = app.db.select().from(runs).where(eq17(runs.id, runId)).get();
     return run;
   });
   app.post("/projects/:name/bing/request-indexing", async (request) => {
@@ -7370,7 +8100,7 @@ async function bingRoutes(app, opts) {
     }
     let urlsToSubmit = request.body?.urls ?? [];
     if (request.body?.allUnindexed) {
-      const allInspections = app.db.select().from(bingUrlInspections).where(eq15(bingUrlInspections.projectId, project.id)).orderBy(desc6(bingUrlInspections.inspectedAt)).all();
+      const allInspections = app.db.select().from(bingUrlInspections).where(eq17(bingUrlInspections.projectId, project.id)).orderBy(desc8(bingUrlInspections.inspectedAt)).all();
       const latestByUrl = /* @__PURE__ */ new Map();
       for (const row of allInspections) {
         if (!latestByUrl.has(row.url)) {
@@ -7457,14 +8187,14 @@ async function bingRoutes(app, opts) {
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { eq as eq16, and as and5 } from "drizzle-orm";
+import { eq as eq18, and as and7 } from "drizzle-orm";
 function getScreenshotDir() {
   return path.join(os.homedir(), ".canonry", "screenshots");
 }
 async function cdpRoutes(app, opts) {
   app.get("/screenshots/:snapshotId", async (request, reply) => {
     const { snapshotId } = request.params;
-    const snapshot = app.db.select({ screenshotPath: querySnapshots.screenshotPath }).from(querySnapshots).where(eq16(querySnapshots.id, snapshotId)).get();
+    const snapshot = app.db.select({ screenshotPath: querySnapshots.screenshotPath }).from(querySnapshots).where(eq18(querySnapshots.id, snapshotId)).get();
     if (!snapshot?.screenshotPath) {
       const err = notFound("Screenshot", snapshotId);
       return reply.code(err.statusCode).send(err.toJSON());
@@ -7530,7 +8260,7 @@ async function cdpRoutes(app, opts) {
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
       const { runId } = request.params;
-      const run = app.db.select().from(runs).where(and5(eq16(runs.id, runId), eq16(runs.projectId, project.id))).get();
+      const run = app.db.select().from(runs).where(and7(eq18(runs.id, runId), eq18(runs.projectId, project.id))).get();
       if (!run) {
         const err = notFound("Run", runId);
         return reply.code(err.statusCode).send(err.toJSON());
@@ -7543,8 +8273,8 @@ async function cdpRoutes(app, opts) {
         citedDomains: querySnapshots.citedDomains,
         screenshotPath: querySnapshots.screenshotPath,
         rawResponse: querySnapshots.rawResponse
-      }).from(querySnapshots).where(eq16(querySnapshots.runId, runId)).all();
-      const keywordRows = app.db.select({ id: keywords.id, keyword: keywords.keyword }).from(keywords).where(eq16(keywords.projectId, project.id)).all();
+      }).from(querySnapshots).where(eq18(querySnapshots.runId, runId)).all();
+      const keywordRows = app.db.select({ id: keywords.id, keyword: keywords.keyword }).from(keywords).where(eq18(keywords.projectId, project.id)).all();
       const keywordMap = new Map(keywordRows.map((k) => [k.id, k.keyword]));
       const byKeyword = /* @__PURE__ */ new Map();
       for (const snap of snapshots) {
@@ -7627,7 +8357,7 @@ async function cdpRoutes(app, opts) {
 
 // ../api-routes/src/ga.ts
 import crypto16 from "crypto";
-import { eq as eq17, desc as desc7, and as and6, sql as sql4 } from "drizzle-orm";
+import { eq as eq19, desc as desc9, and as and8, sql as sql5 } from "drizzle-orm";
 function gaLog(level, action, ctx) {
   const entry = { ts: (/* @__PURE__ */ new Date()).toISOString(), level, module: "GA4Routes", action, ...ctx };
   const stream = level === "error" ? process.stderr : process.stdout;
@@ -7784,10 +8514,10 @@ async function ga4Routes(app, opts) {
     if (!saConn && !oauthConn) {
       throw notFound("GA4 connection", project.name);
     }
-    app.db.delete(gaTrafficSnapshots).where(eq17(gaTrafficSnapshots.projectId, project.id)).run();
-    app.db.delete(gaTrafficSummaries).where(eq17(gaTrafficSummaries.projectId, project.id)).run();
-    app.db.delete(gaAiReferrals).where(eq17(gaAiReferrals.projectId, project.id)).run();
-    app.db.delete(gaSocialReferrals).where(eq17(gaSocialReferrals.projectId, project.id)).run();
+    app.db.delete(gaTrafficSnapshots).where(eq19(gaTrafficSnapshots.projectId, project.id)).run();
+    app.db.delete(gaTrafficSummaries).where(eq19(gaTrafficSummaries.projectId, project.id)).run();
+    app.db.delete(gaAiReferrals).where(eq19(gaAiReferrals.projectId, project.id)).run();
+    app.db.delete(gaSocialReferrals).where(eq19(gaSocialReferrals.projectId, project.id)).run();
     const propertyId = saConn?.propertyId ?? oauthConn?.propertyId ?? null;
     opts.ga4CredentialStore?.deleteConnection(project.name);
     opts.googleConnectionStore?.deleteConnection(project.canonicalDomain, "ga4");
@@ -7808,7 +8538,7 @@ async function ga4Routes(app, opts) {
     if (!connected) {
       return { connected: false, propertyId: null, clientEmail: null, authMethod: null, lastSyncedAt: null };
     }
-    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq17(gaTrafficSummaries.projectId, project.id)).orderBy(desc7(gaTrafficSummaries.syncedAt)).limit(1).get();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq19(gaTrafficSummaries.projectId, project.id)).orderBy(desc9(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       connected: true,
       propertyId: saConn?.propertyId ?? oauthConn?.propertyId ?? null,
@@ -7867,10 +8597,10 @@ async function ga4Routes(app, opts) {
       app.db.transaction((tx) => {
         if (syncTraffic) {
           tx.delete(gaTrafficSnapshots).where(
-            and6(
-              eq17(gaTrafficSnapshots.projectId, project.id),
-              sql4`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
-              sql4`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
+            and8(
+              eq19(gaTrafficSnapshots.projectId, project.id),
+              sql5`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
+              sql5`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
             )
           ).run();
           for (const row of rows) {
@@ -7889,10 +8619,10 @@ async function ga4Routes(app, opts) {
         }
         if (syncAi) {
           tx.delete(gaAiReferrals).where(
-            and6(
-              eq17(gaAiReferrals.projectId, project.id),
-              sql4`${gaAiReferrals.date} >= ${summary.periodStart}`,
-              sql4`${gaAiReferrals.date} <= ${summary.periodEnd}`
+            and8(
+              eq19(gaAiReferrals.projectId, project.id),
+              sql5`${gaAiReferrals.date} >= ${summary.periodStart}`,
+              sql5`${gaAiReferrals.date} <= ${summary.periodEnd}`
             )
           ).run();
           for (const row of aiReferrals) {
@@ -7912,10 +8642,10 @@ async function ga4Routes(app, opts) {
         }
         if (syncSocial) {
           tx.delete(gaSocialReferrals).where(
-            and6(
-              eq17(gaSocialReferrals.projectId, project.id),
-              sql4`${gaSocialReferrals.date} >= ${summary.periodStart}`,
-              sql4`${gaSocialReferrals.date} <= ${summary.periodEnd}`
+            and8(
+              eq19(gaSocialReferrals.projectId, project.id),
+              sql5`${gaSocialReferrals.date} >= ${summary.periodStart}`,
+              sql5`${gaSocialReferrals.date} <= ${summary.periodEnd}`
             )
           ).run();
           for (const row of socialReferrals) {
@@ -7934,7 +8664,7 @@ async function ga4Routes(app, opts) {
           }
         }
         if (syncSummary) {
-          tx.delete(gaTrafficSummaries).where(eq17(gaTrafficSummaries.projectId, project.id)).run();
+          tx.delete(gaTrafficSummaries).where(eq19(gaTrafficSummaries.projectId, project.id)).run();
           tx.insert(gaTrafficSummaries).values({
             id: crypto16.randomUUID(),
             projectId: project.id,
@@ -7948,7 +8678,7 @@ async function ga4Routes(app, opts) {
           }).run();
         }
       });
-      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq17(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.completed, finishedAt: now }).where(eq19(runs.id, runId)).run();
       const syncedComponents = only ? [only, ...only !== "social" && only !== "ai" && only !== "traffic" ? [] : []] : void 0;
       gaLog("info", "sync.complete", {
         projectId: project.id,
@@ -7972,7 +8702,7 @@ async function ga4Routes(app, opts) {
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       gaLog("error", "sync.fetch-failed", { projectId: project.id, runId, error: msg });
-      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq17(runs.id, runId)).run();
+      app.db.update(runs).set({ status: RunStatuses.failed, error: msg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq19(runs.id, runId)).run();
       throw e;
     }
   });
@@ -7983,48 +8713,48 @@ async function ga4Routes(app, opts) {
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const cutoffDate = cutoff?.slice(0, 10) ?? null;
-    const snapshotConditions = [eq17(gaTrafficSnapshots.projectId, project.id)];
-    if (cutoffDate) snapshotConditions.push(sql4`${gaTrafficSnapshots.date} >= ${cutoffDate}`);
-    const aiConditions = [eq17(gaAiReferrals.projectId, project.id)];
-    if (cutoffDate) aiConditions.push(sql4`${gaAiReferrals.date} >= ${cutoffDate}`);
-    const socialConditions = [eq17(gaSocialReferrals.projectId, project.id)];
-    if (cutoffDate) socialConditions.push(sql4`${gaSocialReferrals.date} >= ${cutoffDate}`);
+    const snapshotConditions = [eq19(gaTrafficSnapshots.projectId, project.id)];
+    if (cutoffDate) snapshotConditions.push(sql5`${gaTrafficSnapshots.date} >= ${cutoffDate}`);
+    const aiConditions = [eq19(gaAiReferrals.projectId, project.id)];
+    if (cutoffDate) aiConditions.push(sql5`${gaAiReferrals.date} >= ${cutoffDate}`);
+    const socialConditions = [eq19(gaSocialReferrals.projectId, project.id)];
+    if (cutoffDate) socialConditions.push(sql5`${gaSocialReferrals.date} >= ${cutoffDate}`);
     const summaryRow = cutoffDate ? app.db.select({
-      totalSessions: sql4`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)`,
-      totalOrganicSessions: sql4`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)`,
-      totalUsers: sql4`COALESCE(SUM(${gaTrafficSnapshots.users}), 0)`
-    }).from(gaTrafficSnapshots).where(and6(...snapshotConditions)).get() : app.db.select({
+      totalSessions: sql5`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)`,
+      totalOrganicSessions: sql5`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)`,
+      totalUsers: sql5`COALESCE(SUM(${gaTrafficSnapshots.users}), 0)`
+    }).from(gaTrafficSnapshots).where(and8(...snapshotConditions)).get() : app.db.select({
       totalSessions: gaTrafficSummaries.totalSessions,
       totalOrganicSessions: gaTrafficSummaries.totalOrganicSessions,
       totalUsers: gaTrafficSummaries.totalUsers
-    }).from(gaTrafficSummaries).where(eq17(gaTrafficSummaries.projectId, project.id)).get();
+    }).from(gaTrafficSummaries).where(eq19(gaTrafficSummaries.projectId, project.id)).get();
     const summaryMeta = app.db.select({
       periodStart: gaTrafficSummaries.periodStart,
       periodEnd: gaTrafficSummaries.periodEnd
-    }).from(gaTrafficSummaries).where(eq17(gaTrafficSummaries.projectId, project.id)).get();
+    }).from(gaTrafficSummaries).where(eq19(gaTrafficSummaries.projectId, project.id)).get();
     const rows = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql4`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(and6(...snapshotConditions)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
+      sessions: sql5`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql5`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql5`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(and8(...snapshotConditions)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql5`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
     const aiReferrals = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
       sourceDimension: gaAiReferrals.sourceDimension,
-      sessions: sql4`SUM(${gaAiReferrals.sessions})`,
-      users: sql4`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(and6(...aiConditions)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.sourceDimension).orderBy(sql4`SUM(${gaAiReferrals.sessions}) DESC`).all();
+      sessions: sql5`SUM(${gaAiReferrals.sessions})`,
+      users: sql5`SUM(${gaAiReferrals.users})`
+    }).from(gaAiReferrals).where(and8(...aiConditions)).groupBy(gaAiReferrals.source, gaAiReferrals.medium, gaAiReferrals.sourceDimension).orderBy(sql5`SUM(${gaAiReferrals.sessions}) DESC`).all();
     const aiDeduped = app.db.select({
-      sessions: sql4`SUM(max_sessions)`,
-      users: sql4`SUM(max_users)`
+      sessions: sql5`SUM(max_sessions)`,
+      users: sql5`SUM(max_users)`
     }).from(
-      sql4`(
+      sql5`(
           SELECT date, source, medium,
                  MAX(sessions) AS max_sessions,
                  MAX(users) AS max_users
           FROM ga_ai_referrals
-          WHERE project_id = ${project.id}${cutoffDate ? sql4` AND date >= ${cutoffDate}` : sql4``}
+          WHERE project_id = ${project.id}${cutoffDate ? sql5` AND date >= ${cutoffDate}` : sql5``}
           GROUP BY date, source, medium
         )`
     ).get();
@@ -8032,14 +8762,14 @@ async function ga4Routes(app, opts) {
       source: gaSocialReferrals.source,
       medium: gaSocialReferrals.medium,
       channelGroup: gaSocialReferrals.channelGroup,
-      sessions: sql4`SUM(${gaSocialReferrals.sessions})`,
-      users: sql4`SUM(${gaSocialReferrals.users})`
-    }).from(gaSocialReferrals).where(and6(...socialConditions)).groupBy(gaSocialReferrals.source, gaSocialReferrals.medium, gaSocialReferrals.channelGroup).orderBy(sql4`SUM(${gaSocialReferrals.sessions}) DESC`).all();
+      sessions: sql5`SUM(${gaSocialReferrals.sessions})`,
+      users: sql5`SUM(${gaSocialReferrals.users})`
+    }).from(gaSocialReferrals).where(and8(...socialConditions)).groupBy(gaSocialReferrals.source, gaSocialReferrals.medium, gaSocialReferrals.channelGroup).orderBy(sql5`SUM(${gaSocialReferrals.sessions}) DESC`).all();
     const socialTotals = app.db.select({
-      sessions: sql4`SUM(${gaSocialReferrals.sessions})`,
-      users: sql4`SUM(${gaSocialReferrals.users})`
-    }).from(gaSocialReferrals).where(and6(...socialConditions)).get();
-    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq17(gaTrafficSummaries.projectId, project.id)).orderBy(desc7(gaTrafficSummaries.syncedAt)).limit(1).get();
+      sessions: sql5`SUM(${gaSocialReferrals.sessions})`,
+      users: sql5`SUM(${gaSocialReferrals.users})`
+    }).from(gaSocialReferrals).where(and8(...socialConditions)).get();
+    const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq19(gaTrafficSummaries.projectId, project.id)).orderBy(desc9(gaTrafficSummaries.syncedAt)).limit(1).get();
     const total = summaryRow?.totalSessions ?? 0;
     return {
       totalSessions: total,
@@ -8086,8 +8816,8 @@ async function ga4Routes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const cutoffDate = windowCutoff(parseWindow(request.query.window))?.slice(0, 10) ?? null;
-    const conditions = [eq17(gaAiReferrals.projectId, project.id)];
-    if (cutoffDate) conditions.push(sql4`${gaAiReferrals.date} >= ${cutoffDate}`);
+    const conditions = [eq19(gaAiReferrals.projectId, project.id)];
+    if (cutoffDate) conditions.push(sql5`${gaAiReferrals.date} >= ${cutoffDate}`);
     const rows = app.db.select({
       date: gaAiReferrals.date,
       source: gaAiReferrals.source,
@@ -8095,15 +8825,15 @@ async function ga4Routes(app, opts) {
       sourceDimension: gaAiReferrals.sourceDimension,
       sessions: gaAiReferrals.sessions,
       users: gaAiReferrals.users
-    }).from(gaAiReferrals).where(and6(...conditions)).orderBy(gaAiReferrals.date).all();
+    }).from(gaAiReferrals).where(and8(...conditions)).orderBy(gaAiReferrals.date).all();
     return rows;
   });
   app.get("/projects/:name/ga/social-referral-history", async (request, _reply) => {
     const project = resolveProject(app.db, request.params.name);
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const cutoffDate = windowCutoff(parseWindow(request.query.window))?.slice(0, 10) ?? null;
-    const conditions = [eq17(gaSocialReferrals.projectId, project.id)];
-    if (cutoffDate) conditions.push(sql4`${gaSocialReferrals.date} >= ${cutoffDate}`);
+    const conditions = [eq19(gaSocialReferrals.projectId, project.id)];
+    if (cutoffDate) conditions.push(sql5`${gaSocialReferrals.date} >= ${cutoffDate}`);
     const rows = app.db.select({
       date: gaSocialReferrals.date,
       source: gaSocialReferrals.source,
@@ -8111,7 +8841,7 @@ async function ga4Routes(app, opts) {
       channelGroup: gaSocialReferrals.channelGroup,
       sessions: gaSocialReferrals.sessions,
       users: gaSocialReferrals.users
-    }).from(gaSocialReferrals).where(and6(...conditions)).orderBy(gaSocialReferrals.date).all();
+    }).from(gaSocialReferrals).where(and8(...conditions)).orderBy(gaSocialReferrals.date).all();
     return rows;
   });
   app.get("/projects/:name/ga/social-referral-trend", async (request, _reply) => {
@@ -8124,10 +8854,10 @@ async function ga4Routes(app, opts) {
       d.setDate(d.getDate() - n);
       return fmt(d);
     };
-    const sumSocial = (from, to) => app.db.select({ sessions: sql4`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and6(
-      eq17(gaSocialReferrals.projectId, project.id),
-      sql4`${gaSocialReferrals.date} >= ${from}`,
-      sql4`${gaSocialReferrals.date} < ${to}`
+    const sumSocial = (from, to) => app.db.select({ sessions: sql5`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and8(
+      eq19(gaSocialReferrals.projectId, project.id),
+      sql5`${gaSocialReferrals.date} >= ${from}`,
+      sql5`${gaSocialReferrals.date} < ${to}`
     )).get();
     const current7d = sumSocial(daysAgo2(7), fmt(today));
     const prev7d = sumSocial(daysAgo2(14), daysAgo2(7));
@@ -8136,19 +8866,19 @@ async function ga4Routes(app, opts) {
     const pct = (cur, prev) => prev === 0 ? null : Math.round((cur - prev) / prev * 100);
     const sourceCurrent = app.db.select({
       source: gaSocialReferrals.source,
-      sessions: sql4`SUM(${gaSocialReferrals.sessions})`
-    }).from(gaSocialReferrals).where(and6(
-      eq17(gaSocialReferrals.projectId, project.id),
-      sql4`${gaSocialReferrals.date} >= ${daysAgo2(7)}`,
-      sql4`${gaSocialReferrals.date} < ${fmt(today)}`
+      sessions: sql5`SUM(${gaSocialReferrals.sessions})`
+    }).from(gaSocialReferrals).where(and8(
+      eq19(gaSocialReferrals.projectId, project.id),
+      sql5`${gaSocialReferrals.date} >= ${daysAgo2(7)}`,
+      sql5`${gaSocialReferrals.date} < ${fmt(today)}`
     )).groupBy(gaSocialReferrals.source).all();
     const sourcePrev = app.db.select({
       source: gaSocialReferrals.source,
-      sessions: sql4`SUM(${gaSocialReferrals.sessions})`
-    }).from(gaSocialReferrals).where(and6(
-      eq17(gaSocialReferrals.projectId, project.id),
-      sql4`${gaSocialReferrals.date} >= ${daysAgo2(14)}`,
-      sql4`${gaSocialReferrals.date} < ${daysAgo2(7)}`
+      sessions: sql5`SUM(${gaSocialReferrals.sessions})`
+    }).from(gaSocialReferrals).where(and8(
+      eq19(gaSocialReferrals.projectId, project.id),
+      sql5`${gaSocialReferrals.date} >= ${daysAgo2(14)}`,
+      sql5`${gaSocialReferrals.date} < ${daysAgo2(7)}`
     )).groupBy(gaSocialReferrals.source).all();
     const prevMap = new Map(sourcePrev.map((r) => [r.source, r.sessions]));
     let biggestMover = null;
@@ -8187,15 +8917,15 @@ async function ga4Routes(app, opts) {
       return fmt(d);
     };
     const pct = (cur, prev) => prev === 0 ? null : Math.round((cur - prev) / prev * 100);
-    const sumTotal = (from, to) => app.db.select({ sessions: sql4`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)` }).from(gaTrafficSnapshots).where(and6(eq17(gaTrafficSnapshots.projectId, project.id), sql4`${gaTrafficSnapshots.date} >= ${from}`, sql4`${gaTrafficSnapshots.date} < ${to}`)).get();
-    const sumOrganic = (from, to) => app.db.select({ sessions: sql4`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)` }).from(gaTrafficSnapshots).where(and6(eq17(gaTrafficSnapshots.projectId, project.id), sql4`${gaTrafficSnapshots.date} >= ${from}`, sql4`${gaTrafficSnapshots.date} < ${to}`)).get();
-    const sumAi = (from, to) => app.db.select({ sessions: sql4`COALESCE(SUM(max_sessions), 0)` }).from(sql4`(
+    const sumTotal = (from, to) => app.db.select({ sessions: sql5`COALESCE(SUM(${gaTrafficSnapshots.sessions}), 0)` }).from(gaTrafficSnapshots).where(and8(eq19(gaTrafficSnapshots.projectId, project.id), sql5`${gaTrafficSnapshots.date} >= ${from}`, sql5`${gaTrafficSnapshots.date} < ${to}`)).get();
+    const sumOrganic = (from, to) => app.db.select({ sessions: sql5`COALESCE(SUM(${gaTrafficSnapshots.organicSessions}), 0)` }).from(gaTrafficSnapshots).where(and8(eq19(gaTrafficSnapshots.projectId, project.id), sql5`${gaTrafficSnapshots.date} >= ${from}`, sql5`${gaTrafficSnapshots.date} < ${to}`)).get();
+    const sumAi = (from, to) => app.db.select({ sessions: sql5`COALESCE(SUM(max_sessions), 0)` }).from(sql5`(
         SELECT date, source, medium, MAX(sessions) AS max_sessions
         FROM ga_ai_referrals
         WHERE project_id = ${project.id} AND date >= ${from} AND date < ${to}
         GROUP BY date, source, medium
       )`).get();
-    const sumSocial = (from, to) => app.db.select({ sessions: sql4`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and6(eq17(gaSocialReferrals.projectId, project.id), sql4`${gaSocialReferrals.date} >= ${from}`, sql4`${gaSocialReferrals.date} < ${to}`)).get();
+    const sumSocial = (from, to) => app.db.select({ sessions: sql5`COALESCE(SUM(${gaSocialReferrals.sessions}), 0)` }).from(gaSocialReferrals).where(and8(eq19(gaSocialReferrals.projectId, project.id), sql5`${gaSocialReferrals.date} >= ${from}`, sql5`${gaSocialReferrals.date} < ${to}`)).get();
     const todayStr = fmt(today);
     const buildTrend = (sum) => {
       const c7 = sum(daysAgo2(7), todayStr)?.sessions ?? 0;
@@ -8204,18 +8934,18 @@ async function ga4Routes(app, opts) {
       const p30 = sum(daysAgo2(60), daysAgo2(30))?.sessions ?? 0;
       return { sessions7d: c7, sessionsPrev7d: p7, trend7dPct: pct(c7, p7), sessions30d: c30, sessionsPrev30d: p30, trend30dPct: pct(c30, p30) };
     };
-    const aiSourceCurrent = app.db.select({ source: sql4`source`, sessions: sql4`COALESCE(SUM(max_sessions), 0)` }).from(sql4`(
+    const aiSourceCurrent = app.db.select({ source: sql5`source`, sessions: sql5`COALESCE(SUM(max_sessions), 0)` }).from(sql5`(
         SELECT date, source, medium, MAX(sessions) AS max_sessions
         FROM ga_ai_referrals
         WHERE project_id = ${project.id} AND date >= ${daysAgo2(7)} AND date < ${todayStr}
         GROUP BY date, source, medium
-      )`).groupBy(sql4`source`).all();
-    const aiSourcePrev = app.db.select({ source: sql4`source`, sessions: sql4`COALESCE(SUM(max_sessions), 0)` }).from(sql4`(
+      )`).groupBy(sql5`source`).all();
+    const aiSourcePrev = app.db.select({ source: sql5`source`, sessions: sql5`COALESCE(SUM(max_sessions), 0)` }).from(sql5`(
         SELECT date, source, medium, MAX(sessions) AS max_sessions
         FROM ga_ai_referrals
         WHERE project_id = ${project.id} AND date >= ${daysAgo2(14)} AND date < ${daysAgo2(7)}
         GROUP BY date, source, medium
-      )`).groupBy(sql4`source`).all();
+      )`).groupBy(sql5`source`).all();
     const findBiggestMover = (current, prev) => {
       const prevMap = new Map(prev.map((r) => [r.source, r.sessions]));
       let mover = null;
@@ -8230,8 +8960,8 @@ async function ga4Routes(app, opts) {
       }
       return mover;
     };
-    const socialSourceCurrent = app.db.select({ source: gaSocialReferrals.source, sessions: sql4`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and6(eq17(gaSocialReferrals.projectId, project.id), sql4`${gaSocialReferrals.date} >= ${daysAgo2(7)}`, sql4`${gaSocialReferrals.date} < ${todayStr}`)).groupBy(gaSocialReferrals.source).all();
-    const socialSourcePrev = app.db.select({ source: gaSocialReferrals.source, sessions: sql4`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and6(eq17(gaSocialReferrals.projectId, project.id), sql4`${gaSocialReferrals.date} >= ${daysAgo2(14)}`, sql4`${gaSocialReferrals.date} < ${daysAgo2(7)}`)).groupBy(gaSocialReferrals.source).all();
+    const socialSourceCurrent = app.db.select({ source: gaSocialReferrals.source, sessions: sql5`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and8(eq19(gaSocialReferrals.projectId, project.id), sql5`${gaSocialReferrals.date} >= ${daysAgo2(7)}`, sql5`${gaSocialReferrals.date} < ${todayStr}`)).groupBy(gaSocialReferrals.source).all();
+    const socialSourcePrev = app.db.select({ source: gaSocialReferrals.source, sessions: sql5`SUM(${gaSocialReferrals.sessions})` }).from(gaSocialReferrals).where(and8(eq19(gaSocialReferrals.projectId, project.id), sql5`${gaSocialReferrals.date} >= ${daysAgo2(14)}`, sql5`${gaSocialReferrals.date} < ${daysAgo2(7)}`)).groupBy(gaSocialReferrals.source).all();
     return {
       total: buildTrend(sumTotal),
       organic: buildTrend(sumOrganic),
@@ -8245,14 +8975,14 @@ async function ga4Routes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const cutoffDate = windowCutoff(parseWindow(request.query.window))?.slice(0, 10) ?? null;
-    const conditions = [eq17(gaTrafficSnapshots.projectId, project.id)];
-    if (cutoffDate) conditions.push(sql4`${gaTrafficSnapshots.date} >= ${cutoffDate}`);
+    const conditions = [eq19(gaTrafficSnapshots.projectId, project.id)];
+    if (cutoffDate) conditions.push(sql5`${gaTrafficSnapshots.date} >= ${cutoffDate}`);
     const rows = app.db.select({
       date: gaTrafficSnapshots.date,
-      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql4`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(and6(...conditions)).groupBy(gaTrafficSnapshots.date).orderBy(gaTrafficSnapshots.date).all();
+      sessions: sql5`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql5`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql5`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(and8(...conditions)).groupBy(gaTrafficSnapshots.date).orderBy(gaTrafficSnapshots.date).all();
     return rows.map((r) => ({
       date: r.date,
       sessions: r.sessions ?? 0,
@@ -8265,10 +8995,10 @@ async function ga4Routes(app, opts) {
     requireGa4Connection(opts, project.name, project.canonicalDomain);
     const trafficPages = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql4`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq17(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
+      sessions: sql5`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql5`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql5`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq19(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql5`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
     return {
       pages: trafficPages.map((r) => ({
         landingPage: r.landingPage,
@@ -9905,7 +10635,7 @@ async function wordpressRoutes(app, opts) {
 
 // ../api-routes/src/backlinks.ts
 import crypto18 from "crypto";
-import { and as and7, asc as asc2, desc as desc8, eq as eq18, sql as sql5 } from "drizzle-orm";
+import { and as and9, asc as asc2, desc as desc10, eq as eq20, sql as sql6 } from "drizzle-orm";
 
 // ../integration-commoncrawl/src/constants.ts
 import os2 from "os";
@@ -10135,7 +10865,7 @@ async function queryBacklinks(opts) {
   const reversed = opts.targets.map(reverseDomain);
   const targetList = reversed.map(quote).join(", ");
   const limitClause = opts.limitPerTarget ? `QUALIFY row_number() OVER (PARTITION BY t.target_rev_domain ORDER BY v.num_hosts DESC) <= ${Math.floor(opts.limitPerTarget)}` : "";
-  const sql10 = `
+  const sql11 = `
     WITH vertices AS (
       SELECT * FROM read_csv(
         ${quote(opts.vertexPath)},
@@ -10171,7 +10901,7 @@ async function queryBacklinks(opts) {
   const conn = await instance.connect();
   let rows;
   try {
-    const reader = await conn.runAndReadAll(sql10);
+    const reader = await conn.runAndReadAll(sql11);
     rows = reader.getRowObjects();
   } finally {
     conn.disconnectSync?.();
@@ -10303,8 +11033,8 @@ function mapRunRow(row) {
   };
 }
 function latestSummaryForProject(db, projectId, release) {
-  const condition = release ? and7(eq18(backlinkSummaries.projectId, projectId), eq18(backlinkSummaries.release, release)) : eq18(backlinkSummaries.projectId, projectId);
-  return db.select().from(backlinkSummaries).where(condition).orderBy(desc8(backlinkSummaries.queriedAt)).limit(1).get();
+  const condition = release ? and9(eq20(backlinkSummaries.projectId, projectId), eq20(backlinkSummaries.release, release)) : eq20(backlinkSummaries.projectId, projectId);
+  return db.select().from(backlinkSummaries).where(condition).orderBy(desc10(backlinkSummaries.queriedAt)).limit(1).get();
 }
 async function backlinksRoutes(app, opts) {
   app.get("/backlinks/status", async (_request, reply) => {
@@ -10333,7 +11063,7 @@ async function backlinksRoutes(app, opts) {
         "@duckdb/node-api is not installed. Run `canonry backlinks install` to enable the backlinks feature."
       );
     }
-    const existing = app.db.select().from(ccReleaseSyncs).where(eq18(ccReleaseSyncs.release, release)).get();
+    const existing = app.db.select().from(ccReleaseSyncs).where(eq20(ccReleaseSyncs.release, release)).get();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (existing) {
       if (NON_TERMINAL_SYNC_STATUSES.has(existing.status)) {
@@ -10344,9 +11074,9 @@ async function backlinksRoutes(app, opts) {
         phaseDetail: null,
         error: null,
         updatedAt: now
-      }).where(eq18(ccReleaseSyncs.id, existing.id)).run();
+      }).where(eq20(ccReleaseSyncs.id, existing.id)).run();
       opts.onReleaseSyncRequested(existing.id, release);
-      const refreshed = app.db.select().from(ccReleaseSyncs).where(eq18(ccReleaseSyncs.id, existing.id)).get();
+      const refreshed = app.db.select().from(ccReleaseSyncs).where(eq20(ccReleaseSyncs.id, existing.id)).get();
       return reply.status(200).send(mapSyncRow(refreshed));
     }
     const id = crypto18.randomUUID();
@@ -10358,15 +11088,15 @@ async function backlinksRoutes(app, opts) {
       updatedAt: now
     }).run();
     opts.onReleaseSyncRequested(id, release);
-    const inserted = app.db.select().from(ccReleaseSyncs).where(eq18(ccReleaseSyncs.id, id)).get();
+    const inserted = app.db.select().from(ccReleaseSyncs).where(eq20(ccReleaseSyncs.id, id)).get();
     return reply.status(201).send(mapSyncRow(inserted));
   });
   app.get("/backlinks/syncs/latest", async (_request, reply) => {
-    const row = app.db.select().from(ccReleaseSyncs).orderBy(desc8(ccReleaseSyncs.updatedAt)).limit(1).get();
+    const row = app.db.select().from(ccReleaseSyncs).orderBy(desc10(ccReleaseSyncs.updatedAt)).limit(1).get();
     return reply.send(row ? mapSyncRow(row) : null);
   });
   app.get("/backlinks/syncs", async (_request, reply) => {
-    const rows = app.db.select().from(ccReleaseSyncs).orderBy(desc8(ccReleaseSyncs.updatedAt)).all();
+    const rows = app.db.select().from(ccReleaseSyncs).orderBy(desc10(ccReleaseSyncs.updatedAt)).all();
     return reply.send(rows.map(mapSyncRow));
   });
   app.get("/backlinks/releases", async (_request, reply) => {
@@ -10409,7 +11139,7 @@ async function backlinksRoutes(app, opts) {
       createdAt: now
     }).run();
     opts.onBacklinkExtractRequested(runId, project.id, release);
-    const run = app.db.select().from(runs).where(eq18(runs.id, runId)).get();
+    const run = app.db.select().from(runs).where(eq20(runs.id, runId)).get();
     return reply.status(201).send(mapRunRow(run));
   });
   app.get(
@@ -10430,15 +11160,15 @@ async function backlinksRoutes(app, opts) {
     }
     const limit = Math.min(Math.max(parseInt(request.query.limit ?? "50", 10) || 50, 1), 500);
     const offset = Math.max(parseInt(request.query.offset ?? "0", 10) || 0, 0);
-    const domainCondition = and7(
-      eq18(backlinkDomains.projectId, project.id),
-      eq18(backlinkDomains.release, targetRelease)
+    const domainCondition = and9(
+      eq20(backlinkDomains.projectId, project.id),
+      eq20(backlinkDomains.release, targetRelease)
     );
-    const totalRow = app.db.select({ count: sql5`count(*)` }).from(backlinkDomains).where(domainCondition).get();
+    const totalRow = app.db.select({ count: sql6`count(*)` }).from(backlinkDomains).where(domainCondition).get();
     const rows = app.db.select({
       linkingDomain: backlinkDomains.linkingDomain,
       numHosts: backlinkDomains.numHosts
-    }).from(backlinkDomains).where(domainCondition).orderBy(desc8(backlinkDomains.numHosts)).limit(limit).offset(offset).all();
+    }).from(backlinkDomains).where(domainCondition).orderBy(desc10(backlinkDomains.numHosts)).limit(limit).offset(offset).all();
     const response = {
       summary: summaryRow ? mapSummaryRow(summaryRow) : null,
       total: Number(totalRow?.count ?? 0),
@@ -10450,7 +11180,7 @@ async function backlinksRoutes(app, opts) {
     "/projects/:name/backlinks/history",
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
-      const rows = app.db.select().from(backlinkSummaries).where(eq18(backlinkSummaries.projectId, project.id)).orderBy(asc2(backlinkSummaries.queriedAt)).all();
+      const rows = app.db.select().from(backlinkSummaries).where(eq20(backlinkSummaries.projectId, project.id)).orderBy(asc2(backlinkSummaries.queriedAt)).all();
       const response = rows.map((r) => ({
         release: r.release,
         totalLinkingDomains: r.totalLinkingDomains,
@@ -10523,6 +11253,8 @@ async function apiRoutes(app, opts) {
     await api.register(historyRoutes);
     await api.register(analyticsRoutes);
     await api.register(intelligenceRoutes);
+    await api.register(compositeRoutes);
+    await api.register(contentRoutes);
     await api.register(settingsRoutes, {
       providerSummary: opts.providerSummary,
       providerAdapters: opts.providerAdapters,
@@ -12668,7 +13400,7 @@ function hasParsedResponseContent4(rawResponse) {
   return Array.isArray(nestedResponse.choices) && nestedResponse.choices.length > 0 || Array.isArray(nestedResponse.search_results) && nestedResponse.search_results.length > 0 || Array.isArray(nestedResponse.citations) && nestedResponse.citations.length > 0;
 }
 function reparseStoredResult4(rawResponse) {
-  const groundingSources = extractGroundingSources(rawResponse);
+  const groundingSources = extractGroundingSources2(rawResponse);
   return {
     provider: "perplexity",
     answerText: extractAnswerText3(rawResponse),
@@ -12699,7 +13431,7 @@ function extractCitations(rawResponse) {
   }
   return [];
 }
-function extractGroundingSources(rawResponse) {
+function extractGroundingSources2(rawResponse) {
   const searchResults = extractSearchResults(rawResponse);
   if (searchResults.length > 0) {
     const seen = /* @__PURE__ */ new Set();
@@ -13044,7 +13776,7 @@ import crypto19 from "crypto";
 import fs7 from "fs";
 import path9 from "path";
 import os4 from "os";
-import { and as and8, eq as eq19, inArray as inArray3, sql as sql6 } from "drizzle-orm";
+import { and as and10, eq as eq21, inArray as inArray4, sql as sql7 } from "drizzle-orm";
 
 // src/citation-utils.ts
 function domainMatches(domain, canonicalDomain) {
@@ -13296,11 +14028,11 @@ var JobRunner = class {
     this.registry = registry;
   }
   recoverStaleRuns() {
-    const stale = this.db.select({ id: runs.id, status: runs.status }).from(runs).where(inArray3(runs.status, ["running", "queued"])).all();
+    const stale = this.db.select({ id: runs.id, status: runs.status }).from(runs).where(inArray4(runs.status, ["running", "queued"])).all();
     if (stale.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const run of stale) {
-      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq19(runs.id, run.id)).run();
+      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq21(runs.id, run.id)).run();
       log.warn("run.recovered-stale", { runId: run.id, previousStatus: run.status });
     }
   }
@@ -13328,10 +14060,10 @@ var JobRunner = class {
         throw new Error(`Run ${runId} is not executable from status '${existingRun.status}'`);
       }
       if (existingRun.status === "queued") {
-        this.db.update(runs).set({ status: "running", startedAt: now }).where(and8(eq19(runs.id, runId), eq19(runs.status, "queued"))).run();
+        this.db.update(runs).set({ status: "running", startedAt: now }).where(and10(eq21(runs.id, runId), eq21(runs.status, "queued"))).run();
       }
       this.throwIfRunCancelled(runId);
-      const project = this.db.select().from(projects).where(eq19(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq21(projects.id, projectId)).get();
       if (!project) {
         throw new Error(`Project ${projectId} not found`);
       }
@@ -13351,8 +14083,8 @@ var JobRunner = class {
         throw new Error("No providers configured. Add at least one provider API key.");
       }
       log.info("run.dispatch", { runId, providerCount: activeProviders.length, providers: activeProviders.map((p) => p.adapter.name) });
-      projectKeywords = this.db.select().from(keywords).where(eq19(keywords.projectId, projectId)).all();
-      const projectCompetitors = this.db.select().from(competitors).where(eq19(competitors.projectId, projectId)).all();
+      projectKeywords = this.db.select().from(keywords).where(eq21(keywords.projectId, projectId)).all();
+      const projectCompetitors = this.db.select().from(competitors).where(eq21(competitors.projectId, projectId)).all();
       const competitorDomains = projectCompetitors.map((c) => c.domain);
       const allDomains = effectiveDomains({
         canonicalDomain: project.canonicalDomain,
@@ -13368,7 +14100,7 @@ var JobRunner = class {
       const todayPeriod = getCurrentUsageDay();
       for (const p of activeProviders) {
         const providerScope = `${projectId}:${p.adapter.name}`;
-        const providerUsage = this.db.select().from(usageCounters).where(eq19(usageCounters.scope, providerScope)).all().filter((r) => r.period === todayPeriod && r.metric === "queries").reduce((sum, r) => sum + r.count, 0);
+        const providerUsage = this.db.select().from(usageCounters).where(eq21(usageCounters.scope, providerScope)).all().filter((r) => r.period === todayPeriod && r.metric === "queries").reduce((sum, r) => sum + r.count, 0);
         const limit = p.config.quotaPolicy.maxRequestsPerDay;
         if (providerUsage + queriesPerProvider > limit) {
           throw new Error(
@@ -13509,12 +14241,12 @@ var JobRunner = class {
       const someFailed = providerErrors.size > 0;
       if (allFailed) {
         const errorDetail = serializeRunError(buildRunErrorFromMessages(providerErrors));
-        this.db.update(runs).set({ status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq19(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq21(runs.id, runId)).run();
       } else if (someFailed) {
         const errorDetail = serializeRunError(buildRunErrorFromMessages(providerErrors));
-        this.db.update(runs).set({ status: "partial", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq19(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "partial", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq21(runs.id, runId)).run();
       } else {
-        this.db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq19(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(runs.id, runId)).run();
       }
       this.flushProviderUsage(projectId, providerDispatchCounts);
       const finalStatus = allFailed ? "failed" : someFailed ? "partial" : "completed";
@@ -13549,7 +14281,7 @@ var JobRunner = class {
         status: "failed",
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: errorMessage
-      }).where(eq19(runs.id, runId)).run();
+      }).where(eq21(runs.id, runId)).run();
       this.flushProviderUsage(projectId, providerDispatchCounts);
       trackEvent("run.completed", {
         status: "failed",
@@ -13578,7 +14310,7 @@ var JobRunner = class {
       updatedAt: now
     }).onConflictDoUpdate({
       target: [usageCounters.scope, usageCounters.period, usageCounters.metric],
-      set: { count: sql6`${usageCounters.count} + ${count}`, updatedAt: now }
+      set: { count: sql7`${usageCounters.count} + ${count}`, updatedAt: now }
     }).run();
   }
   flushProviderUsage(projectId, providerDispatchCounts) {
@@ -13592,7 +14324,7 @@ var JobRunner = class {
       status: runs.status,
       finishedAt: runs.finishedAt,
       error: runs.error
-    }).from(runs).where(eq19(runs.id, runId)).get();
+    }).from(runs).where(eq21(runs.id, runId)).get();
   }
   isRunCancelled(runId) {
     return this.getRunState(runId)?.status === "cancelled";
@@ -13608,7 +14340,7 @@ var JobRunner = class {
       this.db.update(runs).set({
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: currentRun.error ?? "Cancelled by user"
-      }).where(eq19(runs.id, runId)).run();
+      }).where(eq21(runs.id, runId)).run();
     }
     trackEvent("run.completed", {
       status: "cancelled",
@@ -13631,7 +14363,7 @@ function getCurrentUsageDay() {
 
 // src/gsc-sync.ts
 import crypto20 from "crypto";
-import { eq as eq20, and as and9, sql as sql7 } from "drizzle-orm";
+import { eq as eq22, and as and11, sql as sql8 } from "drizzle-orm";
 var log2 = createLogger("GscSync");
 function formatDate2(d) {
   return d.toISOString().split("T")[0];
@@ -13643,13 +14375,13 @@ function daysAgo(n) {
 }
 async function executeGscSync(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq20(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq22(runs.id, runId)).run();
   try {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getGoogleAuthConfig(opts.config);
     if (!googleClientId || !googleClientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq20(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq22(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -13683,10 +14415,10 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     log2.info("fetch.complete", { runId, projectId, rowCount: rows.length });
     db.delete(gscSearchData).where(
-      and9(
-        eq20(gscSearchData.projectId, projectId),
-        sql7`${gscSearchData.date} >= ${startDate}`,
-        sql7`${gscSearchData.date} <= ${endDate}`
+      and11(
+        eq22(gscSearchData.projectId, projectId),
+        sql8`${gscSearchData.date} >= ${startDate}`,
+        sql8`${gscSearchData.date} <= ${endDate}`
       )
     ).run();
     const batchSize = 500;
@@ -13751,7 +14483,7 @@ async function executeGscSync(db, runId, projectId, opts) {
         log2.error("inspect.url-failed", { runId, projectId, url: pageUrl, error: err instanceof Error ? err.message : String(err) });
       }
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq20(gscUrlInspections.projectId, projectId)).all();
+    const allInspections = db.select().from(gscUrlInspections).where(eq22(gscUrlInspections.projectId, projectId)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       const existing = latestByUrl.get(row.url);
@@ -13772,7 +14504,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = formatDate2(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and9(eq20(gscCoverageSnapshots.projectId, projectId), eq20(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and11(eq22(gscCoverageSnapshots.projectId, projectId), eq22(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto20.randomUUID(),
       projectId,
@@ -13783,11 +14515,11 @@ async function executeGscSync(db, runId, projectId, opts) {
       reasonBreakdown: JSON.stringify(reasonCounts),
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }).run();
-    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(runs.id, runId)).run();
+    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(runs.id, runId)).run();
     log2.info("sync.completed", { runId, projectId, searchDataRows: rows.length, urlInspections: topPages.length, indexed: snapIndexed, notIndexed: snapNotIndexed });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(runs.id, runId)).run();
     log2.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -13795,7 +14527,7 @@ async function executeGscSync(db, runId, projectId, opts) {
 
 // src/gsc-inspect-sitemap.ts
 import crypto21 from "crypto";
-import { eq as eq21, and as and10 } from "drizzle-orm";
+import { eq as eq23, and as and12 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var log3 = createLogger("SitemapParser");
@@ -13916,13 +14648,13 @@ async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
 var log4 = createLogger("InspectSitemap");
 async function executeInspectSitemap(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq21(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq23(runs.id, runId)).run();
   try {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getGoogleAuthConfig(opts.config);
     if (!googleClientId || !googleClientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq21(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq23(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -13990,7 +14722,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         await new Promise((r) => setTimeout(r, 1e3));
       }
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq21(gscUrlInspections.projectId, projectId)).all();
+    const allInspections = db.select().from(gscUrlInspections).where(eq23(gscUrlInspections.projectId, projectId)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       const existing = latestByUrl.get(row.url);
@@ -14011,7 +14743,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and10(eq21(gscCoverageSnapshots.projectId, projectId), eq21(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and12(eq23(gscCoverageSnapshots.projectId, projectId), eq23(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto21.randomUUID(),
       projectId,
@@ -14023,11 +14755,11 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }).run();
     const status = errors > 0 && inspected > 0 ? "partial" : errors === urls.length ? "failed" : "completed";
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(runs.id, runId)).run();
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq23(runs.id, runId)).run();
     log4.info("inspect.completed", { runId, projectId, inspected, errors, total: urls.length, indexed: snapIndexed, notIndexed: snapNotIndexed });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq23(runs.id, runId)).run();
     log4.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -14035,7 +14767,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
 
 // src/bing-inspect-sitemap.ts
 import crypto22 from "crypto";
-import { eq as eq22, desc as desc9 } from "drizzle-orm";
+import { eq as eq24, desc as desc11 } from "drizzle-orm";
 var log5 = createLogger("BingInspectSitemap");
 function parseBingDate2(value) {
   if (!value) return null;
@@ -14053,9 +14785,9 @@ function isBlockingIssueType2(issueType) {
 }
 async function executeBingInspectSitemap(db, runId, projectId, opts) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq22(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq24(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq22(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq24(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -14073,7 +14805,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     if (sitemapUrls.length === 0) {
       throw new Error("No URLs found in sitemap");
     }
-    const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq22(bingUrlInspections.projectId, projectId)).all();
+    const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq24(bingUrlInspections.projectId, projectId)).all();
     const trackedUrls = new Set(trackedRows.map((r) => r.url));
     const discovered = sitemapUrls.filter((u) => !trackedUrls.has(u));
     log5.info("sitemap.diff", {
@@ -14156,7 +14888,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
         await new Promise((r) => setTimeout(r, 1e3));
       }
     }
-    const allInspections = db.select().from(bingUrlInspections).where(eq22(bingUrlInspections.projectId, projectId)).orderBy(desc9(bingUrlInspections.inspectedAt)).all();
+    const allInspections = db.select().from(bingUrlInspections).where(eq24(bingUrlInspections.projectId, projectId)).orderBy(desc11(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -14199,7 +14931,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
       }
     }).run();
     const status = errors === sitemapUrls.length ? RunStatuses.failed : errors > 0 ? RunStatuses.partial : RunStatuses.completed;
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(runs.id, runId)).run();
+    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq24(runs.id, runId)).run();
     log5.info("inspect.completed", {
       runId,
       projectId,
@@ -14213,7 +14945,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
-    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(runs.id, runId)).run();
+    db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq24(runs.id, runId)).run();
     log5.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -14222,7 +14954,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
 // src/commoncrawl-sync.ts
 import crypto23 from "crypto";
 import path10 from "path";
-import { and as and11, eq as eq23, sql as sql8 } from "drizzle-orm";
+import { and as and13, eq as eq25, sql as sql9 } from "drizzle-orm";
 var log6 = createLogger("CommonCrawlSync");
 var INSERT_CHUNK_SIZE = 1e4;
 function defaultDeps() {
@@ -14248,7 +14980,7 @@ async function executeReleaseSync(db, syncId, opts) {
       phaseDetail: "downloading vertices + edges",
       updatedAt: downloadStartedAt,
       error: null
-    }).where(eq23(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq25(ccReleaseSyncs.id, syncId)).run();
     const paths = ccReleasePaths(release);
     const releaseCacheDir = path10.join(deps.cacheDir, release);
     const vertexPath = path10.join(releaseCacheDir, paths.vertexFilename);
@@ -14271,7 +15003,7 @@ async function executeReleaseSync(db, syncId, opts) {
       vertexSha256: vertex.sha256,
       edgesSha256: edges.sha256,
       updatedAt: downloadFinishedAt
-    }).where(eq23(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq25(ccReleaseSyncs.id, syncId)).run();
     const allProjects = db.select().from(projects).all();
     const targets = Array.from(new Set(allProjects.map((p) => p.canonicalDomain)));
     let rows = [];
@@ -14287,8 +15019,8 @@ async function executeReleaseSync(db, syncId, opts) {
     }
     const queriedAt = deps.now().toISOString();
     db.transaction((tx) => {
-      tx.delete(backlinkDomains).where(eq23(backlinkDomains.releaseSyncId, syncId)).run();
-      tx.delete(backlinkSummaries).where(eq23(backlinkSummaries.releaseSyncId, syncId)).run();
+      tx.delete(backlinkDomains).where(eq25(backlinkDomains.releaseSyncId, syncId)).run();
+      tx.delete(backlinkSummaries).where(eq25(backlinkSummaries.releaseSyncId, syncId)).run();
       const expanded = [];
       for (const r of rows) {
         const projectIds = projectsByDomain.get(r.targetDomain);
@@ -14347,7 +15079,7 @@ async function executeReleaseSync(db, syncId, opts) {
       domainsDiscovered: rows.length,
       updatedAt: finishedAt,
       error: null
-    }).where(eq23(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq25(ccReleaseSyncs.id, syncId)).run();
     log6.info("sync.completed", {
       syncId,
       release,
@@ -14377,7 +15109,7 @@ async function executeReleaseSync(db, syncId, opts) {
       error: errorMsg,
       phaseDetail: null,
       updatedAt: finishedAt
-    }).where(eq23(ccReleaseSyncs.id, syncId)).run();
+    }).where(eq25(ccReleaseSyncs.id, syncId)).run();
     log6.error("sync.failed", { syncId, release, error: errorMsg });
     throw err;
   }
@@ -14413,7 +15145,7 @@ function computeSummary(rows) {
 // src/backlink-extract.ts
 import crypto24 from "crypto";
 import fs8 from "fs";
-import { and as and12, desc as desc10, eq as eq24 } from "drizzle-orm";
+import { and as and14, desc as desc12, eq as eq26 } from "drizzle-orm";
 var log7 = createLogger("BacklinkExtract");
 function defaultDeps2() {
   return {
@@ -14425,13 +15157,13 @@ function defaultDeps2() {
 async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
   const deps = { ...defaultDeps2(), ...opts.deps };
   const startedAt = deps.now().toISOString();
-  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq24(runs.id, runId)).run();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq26(runs.id, runId)).run();
   try {
-    const project = db.select().from(projects).where(eq24(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq26(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
-    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq24(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq24(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc10(ccReleaseSyncs.createdAt)).limit(1).get();
+    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq26(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq26(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc12(ccReleaseSyncs.createdAt)).limit(1).get();
     if (!sync) {
       throw new Error("No ready release sync available \u2014 run `canonry backlinks sync` first");
     }
@@ -14459,7 +15191,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     const targetDomain = project.canonicalDomain;
     db.transaction((tx) => {
       tx.delete(backlinkDomains).where(
-        and12(eq24(backlinkDomains.projectId, projectId), eq24(backlinkDomains.release, release))
+        and14(eq26(backlinkDomains.projectId, projectId), eq26(backlinkDomains.release, release))
       ).run();
       if (rows.length > 0) {
         const values = rows.map((r) => ({
@@ -14499,7 +15231,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       }).run();
     });
     const finishedAt = deps.now().toISOString();
-    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq24(runs.id, runId)).run();
+    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq26(runs.id, runId)).run();
     log7.info("extract.completed", { runId, projectId, release, rows: rows.length });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -14508,7 +15240,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       status: RunStatuses.failed,
       error: errorMsg,
       finishedAt
-    }).where(eq24(runs.id, runId)).run();
+    }).where(eq26(runs.id, runId)).run();
     log7.error("extract.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
@@ -14581,7 +15313,7 @@ var ProviderRegistry = class {
 
 // src/scheduler.ts
 import cron from "node-cron";
-import { eq as eq25 } from "drizzle-orm";
+import { eq as eq27 } from "drizzle-orm";
 var log8 = createLogger("Scheduler");
 var Scheduler = class {
   db;
@@ -14593,7 +15325,7 @@ var Scheduler = class {
   }
   /** Load all enabled schedules from DB and register cron jobs. */
   start() {
-    const allSchedules = this.db.select().from(schedules).where(eq25(schedules.enabled, 1)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq27(schedules.enabled, 1)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
@@ -14618,7 +15350,7 @@ var Scheduler = class {
       this.stopTask(projectId, existing, "Stopped");
       this.tasks.delete(projectId);
     }
-    const schedule = this.db.select().from(schedules).where(eq25(schedules.projectId, projectId)).get();
+    const schedule = this.db.select().from(schedules).where(eq27(schedules.projectId, projectId)).get();
     if (schedule && schedule.enabled === 1) {
       this.registerCronTask(schedule);
     }
@@ -14651,14 +15383,14 @@ var Scheduler = class {
     this.db.update(schedules).set({
       nextRunAt: task.getNextRun()?.toISOString() ?? null,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq25(schedules.id, scheduleId)).run();
+    }).where(eq27(schedules.id, scheduleId)).run();
     const label = schedule.preset ?? cronExpr;
     log8.info("cron.registered", { projectId, schedule: label, timezone });
   }
   triggerRun(scheduleId, projectId) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const currentSchedule = this.db.select().from(schedules).where(eq25(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq27(schedules.id, scheduleId)).get();
       if (!currentSchedule || currentSchedule.enabled !== 1) {
         log8.warn("schedule.stale", { scheduleId, projectId, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId);
@@ -14666,7 +15398,7 @@ var Scheduler = class {
       }
       const task = this.tasks.get(projectId);
       const nextRunAt = task?.getNextRun()?.toISOString() ?? null;
-      const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq27(projects.id, projectId)).get();
       if (!project) {
         log8.error("project.not-found", { projectId, msg: "skipping scheduled run" });
         this.remove(projectId);
@@ -14695,7 +15427,7 @@ var Scheduler = class {
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
-        }).where(eq25(schedules.id, currentSchedule.id)).run();
+        }).where(eq27(schedules.id, currentSchedule.id)).run();
         return;
       }
       const runId = queueResult.runId;
@@ -14703,7 +15435,7 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq25(schedules.id, currentSchedule.id)).run();
+      }).where(eq27(schedules.id, currentSchedule.id)).run();
       const scheduleProviders = parseJsonColumn(currentSchedule.providers, []);
       const providers = scheduleProviders.length > 0 ? scheduleProviders : void 0;
       log8.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
@@ -14715,7 +15447,7 @@ var Scheduler = class {
 };
 
 // src/notifier.ts
-import { eq as eq26, desc as desc11, and as and13, or as or2 } from "drizzle-orm";
+import { eq as eq28, desc as desc13, and as and15, or as or3 } from "drizzle-orm";
 import crypto25 from "crypto";
 var log9 = createLogger("Notifier");
 var Notifier = class {
@@ -14728,18 +15460,18 @@ var Notifier = class {
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
     log9.info("run.completed", { runId, projectId });
-    const notifs = this.db.select().from(notifications).where(eq26(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
+    const notifs = this.db.select().from(notifications).where(eq28(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
     if (notifs.length === 0) {
       log9.info("notifications.none-enabled", { projectId });
       return;
     }
     log9.info("notifications.found", { projectId, count: notifs.length });
-    const run = this.db.select().from(runs).where(eq26(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq28(runs.id, runId)).get();
     if (!run) {
       log9.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
-    const project = this.db.select().from(projects).where(eq26(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq28(projects.id, projectId)).get();
     if (!project) {
       log9.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
@@ -14786,11 +15518,11 @@ var Notifier = class {
     if (criticalInsights.length > 0) insightEvents.push("insight.critical");
     if (highInsights.length > 0) insightEvents.push("insight.high");
     if (insightEvents.length === 0) return;
-    const notifs = this.db.select().from(notifications).where(eq26(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
+    const notifs = this.db.select().from(notifications).where(eq28(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq26(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq28(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq26(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq28(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = parseJsonColumn(notif.config, { url: "", events: [] });
@@ -14821,11 +15553,11 @@ var Notifier = class {
   }
   computeTransitions(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
-      and13(
-        eq26(runs.projectId, projectId),
-        or2(eq26(runs.status, "completed"), eq26(runs.status, "partial"))
+      and15(
+        eq28(runs.projectId, projectId),
+        or3(eq28(runs.status, "completed"), eq28(runs.status, "partial"))
       )
-    ).orderBy(desc11(runs.createdAt)).limit(2).all();
+    ).orderBy(desc13(runs.createdAt)).limit(2).all();
     if (recentRuns.length < 2) return [];
     const currentRunId = recentRuns[0].id;
     const previousRunId = recentRuns[1].id;
@@ -14835,12 +15567,12 @@ var Notifier = class {
       keyword: keywords.keyword,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(keywords, eq26(querySnapshots.keywordId, keywords.id)).where(eq26(querySnapshots.runId, currentRunId)).all();
+    }).from(querySnapshots).leftJoin(keywords, eq28(querySnapshots.keywordId, keywords.id)).where(eq28(querySnapshots.runId, currentRunId)).all();
     const previousSnapshots = this.db.select({
       keywordId: querySnapshots.keywordId,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).where(eq26(querySnapshots.runId, previousRunId)).all();
+    }).from(querySnapshots).where(eq28(querySnapshots.runId, previousRunId)).all();
     const prevMap = /* @__PURE__ */ new Map();
     for (const s of previousSnapshots) {
       prevMap.set(`${s.keywordId}:${s.provider}`, s.citationState);
@@ -14957,7 +15689,7 @@ var RunCoordinator = class {
 
 // src/agent/session-registry.ts
 import crypto27 from "crypto";
-import { eq as eq28 } from "drizzle-orm";
+import { eq as eq30 } from "drizzle-orm";
 
 // src/agent/session.ts
 import fs11 from "fs";
@@ -15177,7 +15909,7 @@ import { Type as Type2 } from "@sinclair/typebox";
 
 // src/agent/memory-store.ts
 import crypto26 from "crypto";
-import { and as and14, desc as desc12, eq as eq27, like, sql as sql9 } from "drizzle-orm";
+import { and as and16, desc as desc14, eq as eq29, like as like2, sql as sql10 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -15191,7 +15923,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq27(agentMemory.projectId, projectId)).orderBy(desc12(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq29(agentMemory.projectId, projectId)).orderBy(desc14(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -15222,12 +15954,12 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and14(eq27(agentMemory.projectId, args.projectId), eq27(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and16(eq29(agentMemory.projectId, args.projectId), eq29(agentMemory.key, args.key))).get();
   if (!row) throw new Error("memory upsert produced no row");
   return rowToDto(row);
 }
 function deleteMemoryEntry(db, projectId, key) {
-  const result = db.delete(agentMemory).where(and14(eq27(agentMemory.projectId, projectId), eq27(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and16(eq29(agentMemory.projectId, projectId), eq29(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -15256,16 +15988,16 @@ function writeCompactionNote(db, args) {
     }).run();
     const sessionPrefix = `${COMPACTION_KEY_PREFIX}${args.sessionId}:`;
     const existing = tx.select({ id: agentMemory.id, updatedAt: agentMemory.updatedAt }).from(agentMemory).where(
-      and14(
-        eq27(agentMemory.projectId, args.projectId),
-        like(agentMemory.key, `${sessionPrefix}%`)
+      and16(
+        eq29(agentMemory.projectId, args.projectId),
+        like2(agentMemory.key, `${sessionPrefix}%`)
       )
-    ).orderBy(desc12(agentMemory.updatedAt)).all();
+    ).orderBy(desc14(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
-      tx.delete(agentMemory).where(sql9`${agentMemory.id} IN (${sql9.join(stale.map((s) => sql9`${s}`), sql9`, `)})`).run();
+      tx.delete(agentMemory).where(sql10`${agentMemory.id} IN (${sql10.join(stale.map((s) => sql10`${s}`), sql10`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and14(eq27(agentMemory.projectId, args.projectId), eq27(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and16(eq29(agentMemory.projectId, args.projectId), eq29(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -15395,6 +16127,59 @@ function buildListCompetitorsTool(ctx) {
     }
   };
 }
+var ContentTargetsSchema = Type2.Object({
+  limit: Type2.Optional(
+    Type2.Number({
+      description: "Max rows. Defaults to all. Use a small number (3\u201310) when summarizing for the user."
+    })
+  ),
+  includeInProgress: Type2.Optional(
+    Type2.Boolean({
+      description: "Include rows that already have an in-flight tracked action. Default false."
+    })
+  )
+});
+function buildGetContentTargetsTool(ctx) {
+  return {
+    name: "get_content_targets",
+    label: "Get content targets",
+    description: "Ranked, action-typed content opportunities. Each row is `{query, action \u2208 create|expand|refresh|add-schema, ourBestPage?, winningCompetitor?, score, scoreBreakdown, drivers[], demandSource, actionConfidence}`. Use this to recommend which post the user should write/refresh next.",
+    parameters: ContentTargetsSchema,
+    execute: async (_toolCallId, params) => {
+      const response = await ctx.client.getContentTargets(ctx.projectName, {
+        limit: params.limit,
+        includeInProgress: params.includeInProgress === true
+      });
+      return textResult2(response);
+    }
+  };
+}
+var ContentSourcesSchema = Type2.Object({});
+function buildGetContentSourcesTool(ctx) {
+  return {
+    name: "get_grounding_sources",
+    label: "Get grounding sources",
+    description: "URL-level competitive grounding-source map. Per query, lists every URL the LLM cited (our domain vs competitors), with citation count and providers. Read this to understand what specific competitor URL is winning a query.",
+    parameters: ContentSourcesSchema,
+    execute: async () => {
+      const response = await ctx.client.getContentSources(ctx.projectName);
+      return textResult2(response);
+    }
+  };
+}
+var ContentGapsSchema = Type2.Object({});
+function buildGetContentGapsTool(ctx) {
+  return {
+    name: "get_content_gaps",
+    label: "Get content gaps",
+    description: 'Queries where competitors are cited but our domain is not. Ranked by miss rate. The blunt-instrument view of "what competitors are winning that we are not." Use `get_content_targets` for action-typed recommendations on the same data.',
+    parameters: ContentGapsSchema,
+    execute: async () => {
+      const response = await ctx.client.getContentGaps(ctx.projectName);
+      return textResult2(response);
+    }
+  };
+}
 var RunDetailSchema = Type2.Object({
   runId: Type2.String({
     description: "Run id (UUID) to fetch. Typically obtained from get_status runs[].id."
@@ -15472,7 +16257,10 @@ function buildReadTools(ctx) {
     buildListCompetitorsTool(ctx),
     buildGetRunTool(ctx),
     buildRecallTool(ctx),
-    buildListBacklinksTool(ctx)
+    buildListBacklinksTool(ctx),
+    buildGetContentTargetsTool(ctx),
+    buildGetContentSourcesTool(ctx),
+    buildGetContentGapsTool(ctx)
   ];
 }
 var RunSweepSchema = Type2.Object({
@@ -15941,7 +16729,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq28(agentSessions.projectId, projectId)).run();
+        }).where(eq30(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -16159,7 +16947,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq28(agentSessions.projectId, projectId)).run();
+    }).where(eq30(agentSessions.projectId, projectId)).run();
   }
   /** Persist a session's transcript back to the DB. Call after any run settles. */
   save(projectName) {
@@ -16321,11 +17109,11 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq28(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq30(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq28(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq30(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
@@ -16344,14 +17132,14 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq28(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq30(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/agent-routes.ts
-import { eq as eq29 } from "drizzle-orm";
+import { eq as eq31 } from "drizzle-orm";
 function resolveProject2(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq29(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq31(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -16360,7 +17148,7 @@ function registerAgentRoutes(app, opts) {
     "/projects/:name/agent/transcript",
     async (request) => {
       const project = resolveProject2(opts.db, request.params.name);
-      const row = opts.db.select().from(agentSessions).where(eq29(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq31(agentSessions.projectId, project.id)).get();
       if (!row) {
         return { messages: [], modelProvider: null, modelId: null, updatedAt: null };
       }
@@ -16384,7 +17172,7 @@ function registerAgentRoutes(app, opts) {
     async (request) => {
       const project = resolveProject2(opts.db, request.params.name);
       opts.sessionRegistry.reset(project.name);
-      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq29(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq31(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -16688,7 +17476,7 @@ var SnapshotService = class {
   }
   async createReport(input) {
     const companyName = input.companyName.trim();
-    const domain = normalizeDomain(input.domain);
+    const domain = normalizeDomain2(input.domain);
     const manualPhrases = normalizeStringList(input.phrases ?? []);
     const manualCompetitors = normalizeStringList(input.competitors ?? []);
     const providers = this.registry.getAll();
@@ -17128,7 +17916,7 @@ function extractCompetitorsFromResponse(ctx) {
   const targetDomain = extractHostname2(ctx.targetDomain);
   for (const hint of ctx.manualCompetitors) {
     if (isDomainLike(hint)) {
-      const normalizedHint = normalizeDomain(hint);
+      const normalizedHint = normalizeDomain2(hint);
       if (domainMatches2(normalizedHint, targetDomain)) continue;
       if (ctx.citedDomains.some((domain) => domainMatches2(domain, normalizedHint)) || lowerAnswer.includes(normalizedHint.toLowerCase())) {
         competitors2.add(normalizedHint);
@@ -17187,7 +17975,7 @@ function uniqueStrings2(values) {
     values.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean)
   )];
 }
-function normalizeDomain(value) {
+function normalizeDomain2(value) {
   const trimmed = value.trim();
   if (!trimmed) return trimmed;
   try {
@@ -17198,15 +17986,15 @@ function normalizeDomain(value) {
   }
 }
 function extractHostname2(value) {
-  return normalizeDomain(value);
+  return normalizeDomain2(value);
 }
 function domainMatches2(candidate, target) {
-  const normalizedCandidate = normalizeDomain(candidate);
-  const normalizedTarget = normalizeDomain(target);
+  const normalizedCandidate = normalizeDomain2(candidate);
+  const normalizedTarget = normalizeDomain2(target);
   return normalizedCandidate === normalizedTarget || normalizedCandidate.endsWith(`.${normalizedTarget}`);
 }
 function isDomainLike(value) {
-  const normalized = normalizeDomain(value);
+  const normalized = normalizeDomain2(value);
   return normalized.includes(".") && !normalized.includes(" ");
 }
 function clipText(value, length) {
@@ -17406,7 +18194,7 @@ async function createServer(opts) {
     intelligenceService,
     (runId, projectId, result) => notifier.dispatchInsightWebhooks(runId, projectId, result),
     async ({ runId, projectId, insightCount, criticalOrHigh }) => {
-      const project = opts.db.select({ name: projects.name }).from(projects).where(eq30(projects.id, projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq32(projects.id, projectId)).get();
       if (!project) return;
       sessionRegistry.queueFollowUp(project.name, {
         role: "user",
@@ -17546,7 +18334,7 @@ async function createServer(opts) {
   const apiPrefix = basePath ? `${basePath}api/v1` : "/api/v1";
   if (opts.config.apiKey) {
     const keyHash = hashApiKey(opts.config.apiKey);
-    const existing = opts.db.select().from(apiKeys).where(eq30(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq32(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
@@ -17598,7 +18386,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq30(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq32(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -17655,12 +18443,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq30(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq32(apiKeys.keyHash, hashApiKey(apiKey))).get();
       if (!key || key.revokedAt) {
         const err2 = authInvalid();
         return reply.status(err2.statusCode).send(err2.toJSON());
       }
-      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq30(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq32(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header("set-cookie", serializeSessionCookie({
         name: SESSION_COOKIE_NAME,