@ainyc/canonry 4.34.0 → 4.36.0

package/dist/{chunk-7256SFYT.js → chunk-JQQXMCQ7.js}

@@ -8,7 +8,7 @@ import {
   categoryLabel,
   determineAnswerMentioned,
   normalizeProjectDomain
-} from "./chunk-XW3F5EEW.js";
+} from "./chunk-XJVYVURK.js";
 
 // src/intelligence-service.ts
 import { eq, desc, asc, and, or, inArray } from "drizzle-orm";
@@ -68,6 +68,7 @@ var projects = sqliteTable("projects", {
   displayName: text("display_name").notNull(),
   canonicalDomain: text("canonical_domain").notNull(),
   ownedDomains: text("owned_domains").notNull().default("[]"),
+  aliases: text("aliases").notNull().default("[]"),
   country: text("country").notNull(),
   language: text("language").notNull(),
   tags: text("tags").notNull().default("[]"),
@@ -153,7 +154,12 @@ var querySnapshots = sqliteTable("query_snapshots", {
 ]);
 var auditLog = sqliteTable("audit_log", {
   id: text("id").primaryKey(),
-  projectId: text("project_id").references(() => projects.id, { onDelete: "cascade" }),
+  // SET NULL (not CASCADE) so deleting a project preserves its audit trail.
+  // The DELETE /projects route writes a "project.deleted" row immediately
+  // before the delete — a CASCADE here would wipe that record before any
+  // reader could see it (the deletion would erase the only evidence it
+  // happened). Detached rows surface in audit queries with project_id=NULL.
+  projectId: text("project_id").references(() => projects.id, { onDelete: "set null" }),
   actor: text("actor").notNull(),
   action: text("action").notNull(),
   entityType: text("entity_type").notNull(),
@@ -1885,6 +1891,55 @@ var MIGRATION_VERSIONS = [
       `CREATE INDEX IF NOT EXISTS idx_snapshots_location ON query_snapshots(location)`,
       `CREATE INDEX IF NOT EXISTS idx_snapshots_created_at ON query_snapshots(created_at)`
     ]
+  },
+  {
+    version: 59,
+    name: "projects-aliases",
+    statements: [
+      `ALTER TABLE projects ADD COLUMN aliases TEXT NOT NULL DEFAULT '[]'`
+    ]
+  },
+  {
+    version: 60,
+    name: "audit-log-preserve-on-project-delete",
+    // The legacy `audit_log.project_id` FK was `ON DELETE CASCADE`, so any
+    // `DELETE /projects/:name` call cascade-wiped every audit row for that
+    // project — including the `project.deleted` row the route handler had
+    // just written in the same path. The deletion erased the only record
+    // that the deletion happened, defeating the entire purpose of the
+    // audit log.
+    //
+    // Fix: rebuild `audit_log` with `project_id` as `ON DELETE SET NULL`.
+    // Existing rows survive verbatim; future deletions detach audit rows
+    // from the project (project_id=NULL) instead of erasing them. SQLite
+    // can't change FK behavior in place — same canonical table-rebuild
+    // pattern v58 used for `query_snapshots`.
+    statements: [
+      `CREATE TABLE IF NOT EXISTS audit_log_v60 (
+         id           TEXT PRIMARY KEY,
+         project_id   TEXT REFERENCES projects(id) ON DELETE SET NULL,
+         actor        TEXT NOT NULL,
+         action       TEXT NOT NULL,
+         entity_type  TEXT NOT NULL,
+         entity_id    TEXT,
+         diff         TEXT,
+         created_at   TEXT NOT NULL
+       )`,
+      // LEFT JOIN guard mirrors v58: if a pre-existing row carries a
+      // dangling project_id (from a pre-FK era or a write with
+      // PRAGMA foreign_keys=OFF), the join nulls it out rather than
+      // failing the migration on the new FK validation.
+      `INSERT INTO audit_log_v60 (
+         id, project_id, actor, action, entity_type, entity_id, diff, created_at
+       )
+       SELECT a.id, p.id, a.actor, a.action, a.entity_type, a.entity_id, a.diff, a.created_at
+       FROM audit_log a
+       LEFT JOIN projects p ON p.id = a.project_id`,
+      `DROP TABLE audit_log`,
+      `ALTER TABLE audit_log_v60 RENAME TO audit_log`,
+      `CREATE INDEX IF NOT EXISTS idx_audit_log_project ON audit_log(project_id)`,
+      `CREATE INDEX IF NOT EXISTS idx_audit_log_created ON audit_log(created_at)`
+    ]
   }
 ];
 function isDuplicateColumnError(err) {
@@ -2074,19 +2129,26 @@ function filterTrackedSnapshots(rows) {
 }
 
 // ../intelligence/src/regressions.ts
+function snapshotKey(snap) {
+  const loc = snap.location ?? "__none__";
+  return JSON.stringify([snap.query, snap.provider, loc]);
+}
 function detectRegressions(currentRun, previousRun) {
+  if ((currentRun.location ?? null) !== (previousRun.location ?? null)) {
+    return [];
+  }
   const regressions = [];
   const previousCited = /* @__PURE__ */ new Map();
   for (const snap of previousRun.snapshots) {
     if (snap.cited) {
-      previousCited.set(`${snap.query}:${snap.provider}`, {
+      previousCited.set(snapshotKey(snap), {
         citationUrl: snap.citationUrl,
         position: snap.position
       });
     }
   }
   for (const snap of currentRun.snapshots) {
-    const key = `${snap.query}:${snap.provider}`;
+    const key = snapshotKey(snap);
     if (!snap.cited && previousCited.has(key)) {
       const prev = previousCited.get(key);
       regressions.push({
@@ -2103,16 +2165,23 @@ function detectRegressions(currentRun, previousRun) {
 }
 
 // ../intelligence/src/gains.ts
+function snapshotKey2(snap) {
+  const loc = snap.location ?? "__none__";
+  return JSON.stringify([snap.query, snap.provider, loc]);
+}
 function detectGains(currentRun, previousRun) {
+  if ((currentRun.location ?? null) !== (previousRun.location ?? null)) {
+    return [];
+  }
   const gains = [];
   const previousCited = /* @__PURE__ */ new Set();
   for (const snap of previousRun.snapshots) {
     if (snap.cited) {
-      previousCited.add(`${snap.query}:${snap.provider}`);
+      previousCited.add(snapshotKey2(snap));
     }
   }
   for (const snap of currentRun.snapshots) {
-    const key = `${snap.query}:${snap.provider}`;
+    const key = snapshotKey2(snap);
     if (snap.cited && !previousCited.has(key)) {
       gains.push({
         query: snap.query,
@@ -2173,17 +2242,26 @@ function computeHealthTrend(runs2) {
 
 // ../intelligence/src/causes.ts
 function analyzeCause(regression, currentSnapshots) {
-  const currentSnap = currentSnapshots.find(
-    (s) => s.query === regression.query && s.provider === regression.provider && !s.cited && s.competitorDomains && s.competitorDomains.length > 0
+  const matchingSnaps = currentSnapshots.filter(
+    (s) => s.query === regression.query && s.provider === regression.provider && !s.cited
   );
-  if (currentSnap) {
-    const competitor = currentSnap.competitorDomains[0];
+  const withCompetitor = matchingSnaps.find((s) => s.competitorDomains?.length);
+  if (withCompetitor) {
+    const competitor = withCompetitor.competitorDomains[0];
     return {
       cause: "competitor_gain",
       competitorDomain: competitor,
       details: `Competitor ${competitor} now cited for "${regression.query}" on ${regression.provider}`
     };
   }
+  const withCited = matchingSnaps.find((s) => s.citedDomains?.length);
+  if (withCited) {
+    const top = withCited.citedDomains.slice(0, 3);
+    return {
+      cause: "third_party_displacement",
+      details: `${regression.provider} now grounds on ${top.join(", ")} for "${regression.query}" \u2014 none are tracked competitors.`
+    };
+  }
   return {
     cause: "unknown",
     details: `No specific cause identified for loss of "${regression.query}" on ${regression.provider}`
@@ -2626,10 +2704,13 @@ function buildDrivers(input) {
   if (input.action === "create" && input.position === null) {
     drivers.push("no existing page");
   }
-  if (input.position !== null && input.position > 30) {
-    drivers.push(`page ranks #${input.position} (effectively invisible)`);
-  } else if (input.position !== null && input.position > 10) {
-    drivers.push(`page ranks #${input.position}`);
+  if (input.position !== null) {
+    const positionDisplay = Math.round(input.position);
+    if (input.position > 30) {
+      drivers.push(`page ranks #${positionDisplay} (effectively invisible)`);
+    } else if (input.position > 10) {
+      drivers.push(`page ranks #${positionDisplay}`);
+    }
   }
   if (input.action === "add-schema") {
     drivers.push("cited by LLMs but lacks structured data");
@@ -2900,7 +2981,7 @@ function classifyRegressionSeverity(signals) {
 }
 
 // ../intelligence/src/insight-grouping.ts
-function groupInsights(insights2, keyFn = (i) => `${i.query} ${i.provider} ${i.type}`) {
+function groupInsights(insights2, keyFn = (i) => JSON.stringify([i.query, i.provider, i.type])) {
   const order = [];
   const buckets = /* @__PURE__ */ new Map();
   for (const i of insights2) {
@@ -2932,14 +3013,15 @@ var MIN_BRAND_TOKEN_LENGTH = 3;
 function compact(value) {
   return value.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function buildBrandTokens(canonicalDomain, displayName) {
+function buildBrandTokens(canonicalDomain, brandNames = []) {
   const seen = /* @__PURE__ */ new Set();
   const stem = canonicalDomain.toLowerCase().replace(/\.[a-z]{2,}$/, "");
   const stemCompact = compact(stem);
   if (stemCompact.length >= MIN_BRAND_TOKEN_LENGTH) seen.add(stemCompact);
-  if (displayName) {
-    const displayCompact = compact(displayName);
-    if (displayCompact.length >= MIN_BRAND_TOKEN_LENGTH) seen.add(displayCompact);
+  for (const name of brandNames) {
+    if (!name) continue;
+    const nameCompact = compact(name);
+    if (nameCompact.length >= MIN_BRAND_TOKEN_LENGTH) seen.add(nameCompact);
   }
   return [...seen];
 }
@@ -3086,7 +3168,7 @@ function extractHostFromUri(uri) {
 }
 
 // ../intelligence/src/mention-landscape.ts
-function buildMentionLandscape(snapshots, competitorDomains, projectDisplayName, projectDomains, queryLookup) {
+function buildMentionLandscape(snapshots, competitorDomains, projectBrandNames, projectDomains, queryLookup) {
   let projectMentionCount = 0;
   let totalAnswerSnapshots = 0;
   const competitorMap = /* @__PURE__ */ new Map();
@@ -3100,13 +3182,13 @@ function buildMentionLandscape(snapshots, competitorDomains, projectDisplayName,
     const q = queryLookup.byId.get(snap.queryId);
     const projectMentioned = snap.answerMentioned ?? determineAnswerMentioned(
       text2,
-      projectDisplayName,
+      [...projectBrandNames],
       [...projectDomains]
     );
     if (projectMentioned) projectMentionCount++;
     for (const competitor of competitorDomains) {
       const brand = brandLabelFromDomain(competitor);
-      const mentioned = determineAnswerMentioned(text2, brand, [competitor]);
+      const mentioned = determineAnswerMentioned(text2, brand ? [brand] : [], [competitor]);
       if (mentioned) {
         const entry = competitorMap.get(competitor);
         entry.count++;
@@ -3221,14 +3303,14 @@ function gapTone(gapCount, totalCount) {
 
 // ../intelligence/src/visibility-score.ts
 function buildVisibilityScore(snapshots, options) {
-  const tooltip = 'Percentage of tracked queries where your domain is cited by at least one AI answer engine. A query is "visible" if any configured provider includes your site in its response.';
+  const tooltip = "An LLM used a page on your domain as a source for its answer.";
   if (snapshots.length === 0) {
     return {
-      label: "Answer Visibility",
+      label: "Citation Coverage",
       value: "No data",
       delta: "Run a sweep first",
       tone: "neutral",
-      description: "No visibility data yet. Trigger a run to start tracking.",
+      description: "No citation data yet. Trigger a run to start tracking.",
       tooltip,
       trend: []
     };
@@ -3245,9 +3327,9 @@ function buildVisibilityScore(snapshots, options) {
   const runApiProviderCount = options.configuredApiProviders.filter((p) => runProviders.has(p)).length;
   const isPartialProviderRun = options.configuredApiProviders.length > 1 && runApiProviderCount < options.configuredApiProviders.length;
   return {
-    label: "Answer Visibility",
+    label: "Citation Coverage",
     value: `${score}`,
-    delta: `${citedCount} of ${totalCount} queries visible`,
+    delta: `${citedCount} of ${totalCount} queries cited`,
     tone: isPartialProviderRun ? "caution" : scoreTone(score),
     description: `${citedCount} of ${totalCount} tracked queries found your domain in at least one AI answer engine.`,
     tooltip,
@@ -3257,6 +3339,44 @@ function buildVisibilityScore(snapshots, options) {
   };
 }
 
+// ../intelligence/src/mention-coverage.ts
+function buildMentionCoverage(snapshots, options) {
+  const tooltip = "Your domain or company name was in the answer returned by the LLM.";
+  if (snapshots.length === 0) {
+    return {
+      label: "Mention Coverage",
+      value: "No data",
+      delta: "Run a sweep first",
+      tone: "neutral",
+      description: "No mention data yet. Trigger a run to start tracking.",
+      tooltip,
+      trend: []
+    };
+  }
+  const queryMentioned = /* @__PURE__ */ new Map();
+  for (const snap of snapshots) {
+    if (!queryMentioned.has(snap.queryId)) queryMentioned.set(snap.queryId, false);
+    if (snap.answerMentioned === true) queryMentioned.set(snap.queryId, true);
+  }
+  const totalCount = queryMentioned.size;
+  const mentionedCount = [...queryMentioned.values()].filter(Boolean).length;
+  const score = totalCount > 0 ? Math.round(mentionedCount / totalCount * 100) : 0;
+  const runProviders = new Set(snapshots.map((s) => s.provider));
+  const runApiProviderCount = options.configuredApiProviders.filter((p) => runProviders.has(p)).length;
+  const isPartialProviderRun = options.configuredApiProviders.length > 1 && runApiProviderCount < options.configuredApiProviders.length;
+  return {
+    label: "Mention Coverage",
+    value: `${score}`,
+    delta: `${mentionedCount} of ${totalCount} queries mentioned`,
+    tone: isPartialProviderRun ? "caution" : scoreTone(score),
+    description: `${mentionedCount} of ${totalCount} tracked queries had your brand or domain in the AI answer text.`,
+    tooltip,
+    trend: [],
+    progress: score,
+    providerCoverage: isPartialProviderRun ? `${runApiProviderCount} of ${options.configuredApiProviders.length} providers` : void 0
+  };
+}
+
 // ../intelligence/src/gap-query-score.ts
 function buildGapQueryScore(snapshots) {
   const tooltip = "Tracked queries where a competitor is cited in the latest run but your domain is not.";
@@ -3474,17 +3594,29 @@ var IntelligenceService = class {
       log.info("intelligence.skip", { runId, reason: "run not in recent completed list" });
       return null;
     }
-    const currentRun = this.buildRunData(runId, projectId, currentRunRecord.finishedAt ?? currentRunRecord.createdAt);
+    const currentRun = this.buildRunData(
+      runId,
+      projectId,
+      currentRunRecord.finishedAt ?? currentRunRecord.createdAt,
+      currentRunRecord.location ?? null
+    );
     if (currentRun.snapshots.length === 0) {
       log.info("intelligence.skip", { runId, reason: "no snapshots" });
       return null;
     }
     const orderedRecent = [...recentRuns].reverse();
-    const currentIdx = orderedRecent.findIndex((r) => r.id === runId);
-    const previousRunRecord = currentIdx > 0 ? orderedRecent[currentIdx - 1] : null;
-    const previousRun = previousRunRecord ? this.buildRunData(previousRunRecord.id, projectId, previousRunRecord.finishedAt ?? previousRunRecord.createdAt) : null;
+    const currentLocation = currentRunRecord.location ?? null;
+    const sameLocationOrdered = orderedRecent.filter((r) => (r.location ?? null) === currentLocation);
+    const currentLocIdx = sameLocationOrdered.findIndex((r) => r.id === runId);
+    const previousRunRecord = currentLocIdx > 0 ? sameLocationOrdered[currentLocIdx - 1] : null;
+    const previousRun = previousRunRecord ? this.buildRunData(
+      previousRunRecord.id,
+      projectId,
+      previousRunRecord.finishedAt ?? previousRunRecord.createdAt,
+      previousRunRecord.location ?? null
+    ) : null;
     const trackedCompetitors = this.loadTrackedCompetitors(projectId);
-    const history = orderedRecent.slice(0, currentIdx + 1).map((r) => r.id === runId ? currentRun : this.buildRunData(r.id, projectId, r.finishedAt ?? r.createdAt));
+    const history = sameLocationOrdered.slice(0, currentLocIdx + 1).map((r) => r.id === runId ? currentRun : this.buildRunData(r.id, projectId, r.finishedAt ?? r.createdAt, r.location ?? null));
     if (!previousRun) {
       const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
       log.info("intelligence.analyzed", {
@@ -3517,34 +3649,70 @@ var IntelligenceService = class {
   /**
    * Analyze a single run given an explicit previous run (or null for first run).
    * Used by backfill where we control the run ordering.
+   *
+   * `dryRun: true` skips the DB write — `persistResult` is not called and
+   * dismissed flags / health rows are untouched. Callers receive the same
+   * AnalysisResult they would have, suitable for previewing what a write
+   * would have produced.
    */
-  analyzeRunWithPrevious(runRecord, previousRunRecord, historyRecords) {
-    const currentRun = this.buildRunData(runRecord.id, runRecord.projectId, runRecord.finishedAt ?? runRecord.createdAt);
+  analyzeRunWithPrevious(runRecord, previousRunRecord, historyRecords, opts) {
+    const currentRun = this.buildRunData(
+      runRecord.id,
+      runRecord.projectId,
+      runRecord.finishedAt ?? runRecord.createdAt,
+      runRecord.location ?? null
+    );
     if (currentRun.snapshots.length === 0) {
       return null;
     }
-    const previousRun = previousRunRecord ? this.buildRunData(previousRunRecord.id, previousRunRecord.projectId, previousRunRecord.finishedAt ?? previousRunRecord.createdAt) : null;
+    const previousRun = previousRunRecord ? this.buildRunData(
+      previousRunRecord.id,
+      previousRunRecord.projectId,
+      previousRunRecord.finishedAt ?? previousRunRecord.createdAt,
+      previousRunRecord.location ?? null
+    ) : null;
     const trackedCompetitors = this.loadTrackedCompetitors(runRecord.projectId);
-    const history = (historyRecords ?? []).map((r) => r.id === runRecord.id ? currentRun : this.buildRunData(r.id, r.projectId, r.finishedAt ?? r.createdAt));
+    const history = (historyRecords ?? []).map((r) => r.id === runRecord.id ? currentRun : this.buildRunData(r.id, r.projectId, r.finishedAt ?? r.createdAt, r.location ?? null));
     if (!previousRun) {
       const result2 = analyzeRuns(currentRun, currentRun, { trackedCompetitors, history });
-      this.persistResult(this.emptyAnalysisResult(result2), runRecord.id, runRecord.projectId);
+      const emptyResult = this.emptyAnalysisResult(result2);
+      if (!opts?.dryRun) this.persistResult(emptyResult, runRecord.id, runRecord.projectId);
       return result2;
     }
     const result = analyzeRuns(currentRun, previousRun, { trackedCompetitors, history });
     const tieredResult = this.tierResult(result, runRecord.id, runRecord.projectId);
-    this.persistResult(tieredResult, runRecord.id, runRecord.projectId);
+    if (!opts?.dryRun) this.persistResult(tieredResult, runRecord.id, runRecord.projectId);
     return tieredResult;
   }
   /**
    * Backfill intelligence for all completed/partial runs of a project.
    * Processes runs in chronological order so each run compares against its predecessor.
+   *
+   * Scoping options:
+   *   - `fromRunId` / `toRunId`: bound the target range by exact run ID.
+   *   - `since`: bound the target range by `finishedAt >= <date>`. Accepts
+   *     any string that `Date.parse` understands (ISO 8601, `YYYY-MM-DD`,
+   *     etc.). Runs before the cutoff are *not* re-processed but stay
+   *     available for predecessor lookup, so transition detection at the
+   *     boundary stays correct. Composes with `fromRunId` / `toRunId` —
+   *     all three filters intersect.
+   *   - `dryRun`: compute the analysis without writing. The return value
+   *     includes a `delta` describing what would change (rows to delete vs
+   *     create per run + aggregate). DB is left untouched.
    */
   backfill(projectName, opts, onProgress) {
     const project = this.db.select().from(projects).where(eq(projects.name, projectName)).get();
     if (!project) {
       throw new Error(`Project "${projectName}" not found`);
     }
+    let sinceTimestamp = null;
+    if (opts?.since !== void 0) {
+      const parsed = Date.parse(opts.since);
+      if (Number.isNaN(parsed)) {
+        throw new Error(`Invalid --since value "${opts.since}": expected a parseable date (ISO 8601 or YYYY-MM-DD)`);
+      }
+      sinceTimestamp = parsed;
+    }
     const allRuns = this.db.select().from(runs).where(
       and(
         eq(runs.projectId, project.id),
@@ -3563,26 +3731,65 @@ var IntelligenceService = class {
       if (idx === -1) throw new Error(`Run "${opts.toRunId}" not found in project`);
       endIdx = idx + 1;
     }
-    const targetRuns = allRuns.slice(startIdx, endIdx);
+    let targetRuns = allRuns.slice(startIdx, endIdx);
+    if (sinceTimestamp !== null) {
+      targetRuns = targetRuns.filter((r) => {
+        const ts = r.finishedAt ?? r.createdAt;
+        const t = Date.parse(ts);
+        return !Number.isNaN(t) && t >= sinceTimestamp;
+      });
+    }
     let processed = 0;
     let skipped = 0;
     let totalInsights = 0;
+    const isDryRun = opts?.dryRun === true;
+    const perRunDelta = [];
+    let wouldDeleteTotal = 0;
+    const existingByRunId = /* @__PURE__ */ new Map();
+    if (isDryRun && targetRuns.length > 0) {
+      const rows = this.db.select({ runId: insights.runId }).from(insights).where(inArray(insights.runId, targetRuns.map((r) => r.id))).all();
+      for (const r of rows) {
+        if (r.runId == null) continue;
+        existingByRunId.set(r.runId, (existingByRunId.get(r.runId) ?? 0) + 1);
+      }
+    }
     for (let i = 0; i < targetRuns.length; i++) {
       const run = targetRuns[i];
-      const globalIdx = allRuns.indexOf(run);
-      const previousRun = globalIdx > 0 ? allRuns[globalIdx - 1] : null;
-      const historyStart = Math.max(0, globalIdx - (HISTORY_WINDOW_RUNS - 1));
-      const historyRecords = allRuns.slice(historyStart, globalIdx + 1);
-      const result = this.analyzeRunWithPrevious(run, previousRun, historyRecords);
+      const runLocation = run.location ?? null;
+      const sameLocationRuns = allRuns.filter((r) => (r.location ?? null) === runLocation);
+      const sameLocIdx = sameLocationRuns.indexOf(run);
+      const previousRun = sameLocIdx > 0 ? sameLocationRuns[sameLocIdx - 1] : null;
+      const historyStart = Math.max(0, sameLocIdx - (HISTORY_WINDOW_RUNS - 1));
+      const historyRecords = sameLocationRuns.slice(historyStart, sameLocIdx + 1);
+      const result = this.analyzeRunWithPrevious(run, previousRun, historyRecords, { dryRun: isDryRun });
       if (result) {
         processed++;
         totalInsights += result.insights.length;
+        if (isDryRun) {
+          const existing = existingByRunId.get(run.id) ?? 0;
+          wouldDeleteTotal += existing;
+          perRunDelta.push({ runId: run.id, existingInsights: existing, newInsights: result.insights.length });
+        }
         onProgress?.({ runId: run.id, index: i + 1, total: targetRuns.length, insights: result.insights.length });
       } else {
         skipped++;
         onProgress?.({ runId: run.id, index: i + 1, total: targetRuns.length, insights: 0 });
       }
     }
+    if (isDryRun) {
+      return {
+        processed,
+        skipped,
+        totalInsights,
+        dryRun: true,
+        delta: {
+          wouldDelete: wouldDeleteTotal,
+          wouldCreate: totalInsights,
+          netChange: totalInsights - wouldDeleteTotal,
+          perRun: perRunDelta
+        }
+      };
+    }
     return { processed, skipped, totalInsights };
   }
   loadTrackedCompetitors(projectId) {
@@ -3729,26 +3936,51 @@ var IntelligenceService = class {
       return { ...insight, severity };
     });
   }
-  buildRunData(runId, projectId, completedAt) {
+  buildRunData(runId, projectId, completedAt, location = null) {
     const rows = this.db.select({
       query: queries.query,
+      // Denormalized query text persisted by v58 — the fallback when the
+      // joined queries.query has been hard-deleted (or the query_id was
+      // nulled by the v58 dangling-FK cleanup).
+      queryText: querySnapshots.queryText,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState,
       citedDomains: querySnapshots.citedDomains,
-      competitorOverlap: querySnapshots.competitorOverlap
+      competitorOverlap: querySnapshots.competitorOverlap,
+      snapshotLocation: querySnapshots.location
     }).from(querySnapshots).leftJoin(queries, eq(querySnapshots.queryId, queries.id)).where(eq(querySnapshots.runId, runId)).all();
-    const snapshots = rows.map((r) => {
+    const snapshots = [];
+    let orphanCount = 0;
+    for (const r of rows) {
+      const resolvedQuery = r.query ?? r.queryText ?? null;
+      if (!resolvedQuery) {
+        orphanCount++;
+        continue;
+      }
       const domains = parseJsonColumn(r.citedDomains, []);
       const competitors2 = parseJsonColumn(r.competitorOverlap, []);
-      return {
-        query: r.query ?? "",
+      snapshots.push({
+        query: resolvedQuery,
         provider: r.provider,
         cited: r.citationState === CitationStates.cited,
         citationUrl: domains[0] ?? void 0,
-        competitorDomains: competitors2
-      };
-    });
-    return { runId, projectId, completedAt, snapshots };
+        // Snapshots carry their own location for downstream detectors. In
+        // practice every snapshot in a single runId shares the run's
+        // location; the per-row column is the same value duplicated, but
+        // we read it from the snapshot row so a stale runs.location can't
+        // mask snapshot truth.
+        location: r.snapshotLocation ?? location ?? null,
+        competitorDomains: competitors2,
+        // citedDomains is the FULL set (tracked competitors + third-party
+        // sources). Cause analysis uses it to name the displacing source
+        // when no tracked competitor appears in the response.
+        citedDomains: domains
+      });
+    }
+    if (orphanCount > 0) {
+      log.warn("snapshot.orphan-skip", { runId, projectId, orphanCount });
+    }
+    return { runId, projectId, completedAt, location, snapshots };
   }
 };
 
@@ -3811,6 +4043,7 @@ export {
   buildAiSourceOrigin,
   buildMovementSummary,
   buildVisibilityScore,
+  buildMentionCoverage,
   buildGapQueryScore,
   buildCompetitorPressureScore,
   buildOverviewCompetitors,

package/dist/{chunk-5EBN7736.js → chunk-O7S623DL.js}

@@ -22,7 +22,7 @@ import {
   trafficConnectVercelRequestSchema,
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema
-} from "./chunk-XW3F5EEW.js";
+} from "./chunk-XJVYVURK.js";
 
 // src/config.ts
 import fs from "fs";
@@ -466,6 +466,9 @@ var ApiClient = class {
   async deleteProject(name) {
     await this.request("DELETE", `/projects/${encodeURIComponent(name)}`);
   }
+  async previewProjectDelete(name) {
+    return this.request("GET", `/projects/${encodeURIComponent(name)}/delete-preview`);
+  }
   async putQueries(project, queries) {
     await this.request("PUT", `/projects/${encodeURIComponent(project)}/queries`, { queries });
   }
@@ -1333,6 +1336,17 @@ var canonryMcpTools = [
     openApiOperations: ["GET /api/v1/projects/{name}"],
     handler: (client, input) => client.getProject(input.project)
   }),
+  defineTool({
+    name: "canonry_project_delete_preview",
+    title: "Preview project delete impact",
+    description: "Returns the cascade impact of deleting a project \u2014 how many queries, competitors, runs, snapshots, and insights would be removed, plus how many audit_log rows would be detached (project_id set NULL). Read-only. Use this BEFORE invoking project delete on any project you didn't create yourself; the underlying delete is irreversible.",
+    access: "read",
+    tier: "setup",
+    inputSchema: projectInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/delete-preview"],
+    handler: (client, input) => client.previewProjectDelete(input.project)
+  }),
   defineTool({
     name: "canonry_project_overview",
     title: "Get project overview (composite)",