@ainyc/canonry 1.30.0 → 1.32.0

package/dist/{chunk-LMSO32GF.js → chunk-5Q6LISDM.js}

@@ -494,6 +494,9 @@ function unsupportedKind(kind) {
 function notImplemented(message) {
   return new AppError("NOT_IMPLEMENTED", message, 501);
 }
+function deliveryFailed(message) {
+  return new AppError("DELIVERY_FAILED", message, 502);
+}
 
 // ../contracts/src/google.ts
 import { z as z5 } from "zod";
@@ -781,6 +784,7 @@ var runStatusSchema = z8.enum(["queued", "running", "completed", "partial", "fai
 var runKindSchema = z8.enum(["answer-visibility", "site-audit", "gsc-sync", "inspect-sitemap"]);
 var runTriggerSchema = z8.enum(["manual", "scheduled", "config-apply"]);
 var citationStateSchema = z8.enum(["cited", "not-cited"]);
+var visibilityStateSchema = z8.enum(["visible", "not-visible"]);
 var computedTransitionSchema = z8.enum(["new", "cited", "lost", "emerging", "not-cited"]);
 var runDtoSchema = z8.object({
   id: z8.string(),
@@ -805,6 +809,8 @@ var querySnapshotDtoSchema = z8.object({
   keyword: z8.string().optional(),
   provider: providerNameSchema,
   citationState: citationStateSchema,
+  answerMentioned: z8.boolean().optional(),
+  visibilityState: visibilityStateSchema.optional(),
   transition: computedTransitionSchema.optional(),
   answerText: z8.string().nullable().optional(),
   citedDomains: z8.array(z8.string()).default([]),
@@ -1068,6 +1074,90 @@ var ga4TrafficSummaryDtoSchema = z11.object({
   lastSyncedAt: z11.string().nullable()
 });
 
+// ../contracts/src/answer-visibility.ts
+var GENERIC_TOKENS = /* @__PURE__ */ new Set([
+  "agency",
+  "app",
+  "company",
+  "corp",
+  "group",
+  "health",
+  "inc",
+  "llc",
+  "online",
+  "platform",
+  "services",
+  "site",
+  "solutions",
+  "software",
+  "systems",
+  "tech"
+]);
+function determineAnswerMentioned(answerText, displayName, domains) {
+  if (!answerText) return false;
+  const lowerAnswer = answerText.toLowerCase();
+  for (const domain of domains) {
+    const normalizedDomain = normalizeProjectDomain(domain);
+    if (!normalizedDomain || !normalizedDomain.includes(".")) continue;
+    if (domainMentioned(lowerAnswer, normalizedDomain)) return true;
+  }
+  const normalizedDisplayName = normalizeText(displayName);
+  if (normalizedDisplayName && normalizeText(answerText).includes(normalizedDisplayName)) {
+    return true;
+  }
+  const tokens = collectDistinctiveTokens(displayName, domains);
+  if (tokens.length === 0) return false;
+  let matches = 0;
+  for (const token of tokens) {
+    if (new RegExp(`\\b${escapeRegExp(token)}\\b`).test(lowerAnswer)) {
+      matches++;
+    }
+  }
+  if (tokens.length === 1) {
+    return matches >= 1;
+  }
+  return matches >= Math.min(2, tokens.length);
+}
+function visibilityStateFromAnswerMentioned(answerMentioned) {
+  return answerMentioned ? "visible" : "not-visible";
+}
+function domainMentioned(lowerAnswer, normalizedDomain) {
+  const escapedDomain = escapeRegExp(normalizedDomain.toLowerCase());
+  const patterns = [
+    new RegExp(`(^|[^a-z0-9-])${escapedDomain}($|[^a-z0-9-])`),
+    new RegExp(`https?://(?:www\\.)?${escapedDomain}(?:[/:?#]|$)`),
+    new RegExp(`www\\.${escapedDomain}(?:[/:?#]|$)`)
+  ];
+  return patterns.some((pattern) => pattern.test(lowerAnswer));
+}
+function collectDistinctiveTokens(displayName, domains) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const token of extractDistinctiveTokens(displayName)) {
+    tokens.add(token);
+  }
+  for (const domain of domains) {
+    const hostname = normalizeProjectDomain(domain).split("/")[0] ?? "";
+    for (const label of hostname.split(".").filter(Boolean)) {
+      const token = label.replace(/[^a-z0-9]/gi, "").toLowerCase();
+      if (isDistinctiveToken(token)) tokens.add(token);
+    }
+  }
+  return [...tokens];
+}
+function extractDistinctiveTokens(value) {
+  return normalizeText(value).split(" ").filter(isDistinctiveToken);
+}
+function isDistinctiveToken(token) {
+  if (token.length < 4) return false;
+  return !GENERIC_TOKENS.has(token);
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // ../api-routes/src/auth.ts
 import crypto2 from "crypto";
 import { eq } from "drizzle-orm";
@@ -1162,6 +1252,7 @@ var querySnapshots = sqliteTable("query_snapshots", {
   provider: text("provider").notNull().default("gemini"),
   model: text("model"),
   citationState: text("citation_state").notNull(),
+  answerMentioned: integer("answer_mentioned", { mode: "boolean" }),
   answerText: text("answer_text"),
   citedDomains: text("cited_domains").notNull().default("[]"),
   competitorOverlap: text("competitor_overlap").notNull().default("[]"),
@@ -1406,6 +1497,16 @@ function createClient(databasePath) {
   return drizzle(sqlite, { schema: schema_exports });
 }
 
+// ../db/src/json.ts
+function parseJsonColumn(value, fallback) {
+  if (value == null || value === "") return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
 // ../db/src/migrate.ts
 import { sql } from "drizzle-orm";
 var MIGRATION_SQL = `
@@ -1718,7 +1819,9 @@ var MIGRATIONS = [
   )`,
   `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_project_date ON ga_ai_referrals(project_id, date)`,
   `CREATE INDEX IF NOT EXISTS idx_ga_ai_ref_source ON ga_ai_referrals(source)`,
-  `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique ON ga_ai_referrals(project_id, date, source, medium)`
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_ga_ai_ref_unique ON ga_ai_referrals(project_id, date, source, medium)`,
+  // v18: Answer-level visibility derived from answer text
+  `ALTER TABLE query_snapshots ADD COLUMN answer_mentioned INTEGER`
 ];
 function migrate(db) {
   const statements = MIGRATION_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -1806,7 +1909,7 @@ import { eq as eq3 } from "drizzle-orm";
 
 // ../api-routes/src/helpers.ts
 import crypto3 from "crypto";
-import { eq as eq2, and } from "drizzle-orm";
+import { eq as eq2, sql as sql2 } from "drizzle-orm";
 function resolveProject(db, name) {
   const project = db.select().from(projects).where(eq2(projects.name, name)).get();
   if (!project) {
@@ -1827,6 +1930,23 @@ function writeAuditLog(db, entry) {
     createdAt: now
   }).run();
 }
+function resolveSnapshotAnswerMentioned(snapshot, project) {
+  if (typeof snapshot.answerMentioned === "boolean") {
+    return snapshot.answerMentioned;
+  }
+  return determineAnswerMentioned(snapshot.answerText, project.displayName, effectiveDomains({
+    canonicalDomain: project.canonicalDomain,
+    ownedDomains: normalizeOwnedDomains(project.ownedDomains)
+  }));
+}
+function resolveSnapshotVisibilityState(snapshot, project) {
+  return visibilityStateFromAnswerMentioned(resolveSnapshotAnswerMentioned(snapshot, project));
+}
+function normalizeOwnedDomains(value) {
+  if (Array.isArray(value)) return value.filter((item) => typeof item === "string");
+  const parsed = parseJsonColumn(typeof value === "string" ? value : null, []);
+  return parsed.filter((item) => typeof item === "string");
+}
 
 // ../api-routes/src/projects.ts
 async function projectRoutes(app, opts) {
@@ -1834,43 +1954,39 @@ async function projectRoutes(app, opts) {
     const { name } = request.params;
     const parsedBody = projectUpsertRequestSchema.safeParse(request.body);
     if (!parsedBody.success) {
-      const err = validationError("Invalid project payload", {
+      throw validationError("Invalid project payload", {
         issues: parsedBody.error.issues.map((issue) => ({
           path: issue.path.join("."),
           message: issue.message
         }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const body = parsedBody.data;
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && body.providers?.length) {
       const invalid = body.providers.filter((p) => !validNames.includes(p));
       if (invalid.length) {
-        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+        throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
           invalidProviders: invalid,
           validProviders: validNames
         });
-        return reply.status(err.statusCode).send(err.toJSON());
       }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(projects).where(eq3(projects.name, name)).get();
-    const existingLocations = existing ? JSON.parse(existing.locations || "[]") : [];
+    const existingLocations = existing ? parseJsonColumn(existing.locations, []) : [];
     const nextLocations = body.locations ?? existingLocations;
     const duplicateLabels = findDuplicateLocationLabels(nextLocations);
     if (duplicateLabels.length > 0) {
-      const err = validationError(`Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`, {
+      throw validationError(`Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`, {
         duplicateLabels
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const nextDefaultLocation = body.defaultLocation !== void 0 ? body.defaultLocation ?? null : existing?.defaultLocation ?? null;
     if (!hasLocationLabel(nextLocations, nextDefaultLocation)) {
-      const err = validationError(`defaultLocation "${nextDefaultLocation}" must match a configured location label`, {
+      throw validationError(`defaultLocation "${nextDefaultLocation}" must match a configured location label`, {
         defaultLocation: nextDefaultLocation
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (existing) {
       app.db.update(projects).set({
@@ -1932,28 +2048,11 @@ async function projectRoutes(app, opts) {
     return reply.send(rows.map(formatProject));
   });
   app.get("/projects/:name", async (request, reply) => {
-    try {
-      const project = resolveProject(app.db, request.params.name);
-      return reply.send(formatProject(project));
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
+    return reply.send(formatProject(project));
   });
   app.delete("/projects/:name", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     writeAuditLog(app.db, {
       projectId: project.id,
       actor: "api",
@@ -1966,26 +2065,15 @@ async function projectRoutes(app, opts) {
     return reply.status(204).send();
   });
   app.post("/projects/:name/locations", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const parsed = locationContextSchema.safeParse(request.body);
     if (!parsed.success) {
-      const err = validationError(parsed.error.issues.map((i) => i.message).join(", "));
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(parsed.error.issues.map((i) => i.message).join(", "));
     }
     const location = parsed.data;
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     if (existing.some((l) => l.label === location.label)) {
-      const err = validationError(`Location "${location.label}" already exists`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${location.label}" already exists`);
     }
     existing.push(location);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -2003,39 +2091,20 @@ async function projectRoutes(app, opts) {
     return reply.status(201).send(location);
   });
   app.get("/projects/:name/locations", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
-    const locations = JSON.parse(project.locations || "[]");
+    const project = resolveProject(app.db, request.params.name);
+    const locations = parseJsonColumn(project.locations, []);
     return reply.send({
       locations,
       defaultLocation: project.defaultLocation
     });
   });
   app.delete("/projects/:name/locations/:label", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const label = decodeURIComponent(request.params.label);
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     const filtered = existing.filter((l) => l.label !== label);
     if (filtered.length === existing.length) {
-      const err = validationError(`Location "${label}" not found`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${label}" not found`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const updates = {
@@ -2056,25 +2125,14 @@ async function projectRoutes(app, opts) {
     return reply.status(204).send();
   });
   app.put("/projects/:name/locations/default", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const label = request.body?.label;
     if (!label) {
-      const err = validationError("label is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("label is required");
     }
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     if (!existing.some((l) => l.label === label)) {
-      const err = validationError(`Location "${label}" not found. Add it first.`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${label}" not found. Add it first.`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.update(projects).set({
@@ -2091,16 +2149,7 @@ async function projectRoutes(app, opts) {
     return reply.send({ defaultLocation: label });
   });
   app.get("/projects/:name/export", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const kws = app.db.select().from(keywords).where(eq3(keywords.projectId, project.id)).all();
     const comps = app.db.select().from(competitors).where(eq3(competitors.projectId, project.id)).all();
     const schedule = app.db.select().from(schedules).where(eq3(schedules.projectId, project.id)).get();
@@ -2110,21 +2159,21 @@ async function projectRoutes(app, opts) {
       kind: "Project",
       metadata: {
         name: project.name,
-        labels: JSON.parse(project.labels)
+        labels: parseJsonColumn(project.labels, {})
       },
       spec: {
         displayName: project.displayName,
         canonicalDomain: project.canonicalDomain,
-        ownedDomains: JSON.parse(project.ownedDomains || "[]"),
+        ownedDomains: parseJsonColumn(project.ownedDomains, []),
         country: project.country,
         language: project.language,
         keywords: kws.map((k) => k.keyword),
         competitors: comps.map((c) => c.domain),
-        providers: JSON.parse(project.providers || "[]"),
-        locations: JSON.parse(project.locations || "[]"),
+        providers: parseJsonColumn(project.providers, []),
+        locations: parseJsonColumn(project.locations, []),
         ...project.defaultLocation ? { defaultLocation: project.defaultLocation } : {},
         notifications: notificationRows.map((row) => {
-          const cfg = JSON.parse(row.config);
+          const cfg = parseJsonColumn(row.config, { url: "", events: [] });
           return {
             channel: row.channel,
             url: cfg.url,
@@ -2135,7 +2184,7 @@ async function projectRoutes(app, opts) {
           schedule: {
             ...schedule.preset ? { preset: schedule.preset } : { cron: schedule.cronExpr },
             timezone: schedule.timezone,
-            providers: JSON.parse(schedule.providers || "[]")
+            providers: parseJsonColumn(schedule.providers, [])
           }
         } : {}
       }
@@ -2149,13 +2198,13 @@ function formatProject(row) {
     name: row.name,
     displayName: row.displayName,
     canonicalDomain: row.canonicalDomain,
-    ownedDomains: JSON.parse(row.ownedDomains || "[]"),
+    ownedDomains: parseJsonColumn(row.ownedDomains, []),
     country: row.country,
     language: row.language,
-    tags: JSON.parse(row.tags),
-    labels: JSON.parse(row.labels),
-    providers: JSON.parse(row.providers || "[]"),
-    locations: JSON.parse(row.locations || "[]"),
+    tags: parseJsonColumn(row.tags, []),
+    labels: parseJsonColumn(row.labels, {}),
+    providers: parseJsonColumn(row.providers, []),
+    locations: parseJsonColumn(row.locations, []),
     defaultLocation: row.defaultLocation,
     configSource: row.configSource,
     configRevision: row.configRevision,
@@ -2169,18 +2218,15 @@ import crypto5 from "crypto";
 import { eq as eq4 } from "drizzle-orm";
 async function keywordRoutes(app, opts) {
   app.get("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.put("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords)) {
-      const err = validationError('Body must contain a "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "keywords" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
@@ -2205,12 +2251,10 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.delete("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords) || body.keywords.length === 0) {
-      const err = validationError('Body must contain a non-empty "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a non-empty "keywords" array');
     }
     const existing = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     const toDelete = new Set(body.keywords);
@@ -2233,12 +2277,10 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords)) {
-      const err = validationError('Body must contain a "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "keywords" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
@@ -2269,30 +2311,25 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords/generate", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body?.provider || typeof body.provider !== "string") {
-      const err = validationError('Body must contain a "provider" string');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "provider" string');
     }
     const provider = body.provider.trim().toLowerCase();
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && !validNames.includes(provider)) {
-      const err = validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
+      throw validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
         provider: body.provider,
         validProviders: validNames
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (body.count !== void 0 && (typeof body.count !== "number" || !Number.isFinite(body.count) || !Number.isInteger(body.count))) {
-      const err = validationError('"count" must be an integer');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('"count" must be an integer');
     }
     const count = Math.min(Math.max(body.count ?? 5, 1), 20);
     if (!opts.onGenerateKeywords) {
-      const err = notImplemented("Key phrase generation is not supported in this deployment");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notImplemented("Key phrase generation is not supported in this deployment");
     }
     const existingRows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     const existingKeywords = existingRows.map((r) => r.keyword);
@@ -2316,36 +2353,21 @@ async function keywordRoutes(app, opts) {
     }
   });
 }
-function resolveProjectSafe(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/competitors.ts
 import crypto6 from "crypto";
 import { eq as eq5 } from "drizzle-orm";
 async function competitorRoutes(app) {
   app.get("/projects/:name/competitors", async (request, reply) => {
-    const project = resolveProjectSafe2(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
   });
   app.put("/projects/:name/competitors", async (request, reply) => {
-    const project = resolveProjectSafe2(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.competitors)) {
-      const err = validationError('Body must contain a "competitors" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "competitors" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
@@ -2370,18 +2392,6 @@ async function competitorRoutes(app) {
     return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
   });
 }
-function resolveProjectSafe2(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/runs.ts
 import crypto8 from "crypto";
@@ -2389,7 +2399,7 @@ import { eq as eq7, asc, desc } from "drizzle-orm";
 
 // ../api-routes/src/run-queue.ts
 import crypto7 from "crypto";
-import { and as and2, eq as eq6, or } from "drizzle-orm";
+import { and, eq as eq6, or } from "drizzle-orm";
 function queueRunIfProjectIdle(db, params) {
   const createdAt = params.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const kind = params.kind ?? "answer-visibility";
@@ -2397,7 +2407,7 @@ function queueRunIfProjectIdle(db, params) {
   const runId = crypto7.randomUUID();
   return db.transaction((tx) => {
     const activeRun = tx.select().from(runs).where(
-      and2(
+      and(
         eq6(runs.projectId, params.projectId),
         or(eq6(runs.status, "queued"), eq6(runs.status, "running"))
       )
@@ -2421,13 +2431,9 @@ function queueRunIfProjectIdle(db, params) {
 // ../api-routes/src/runs.ts
 async function runRoutes(app, opts) {
   app.post("/projects/:name/runs", async (request, reply) => {
-    const project = resolveProjectSafe3(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const kind = request.body?.kind ?? "answer-visibility";
-    if (kind !== "answer-visibility") {
-      const err = unsupportedKind(kind);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (kind !== "answer-visibility") throw unsupportedKind(kind);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const trigger = request.body?.trigger ?? "manual";
     const rawProviders = request.body?.providers;
@@ -2437,31 +2443,30 @@ async function runRoutes(app, opts) {
       if (validNames.length) {
         const invalid = normalized.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: invalid,
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
       rawProviders.splice(0, rawProviders.length, ...normalized);
     }
     const providers = rawProviders?.length ? rawProviders : void 0;
     let resolvedLocation;
-    const projectLocations = JSON.parse(project.locations || "[]");
+    const projectLocations = parseJsonColumn(project.locations, []);
     if (request.body?.noLocation) {
       resolvedLocation = null;
     } else if (request.body?.allLocations) {
     } else if (request.body?.location) {
       const loc = projectLocations.find((l) => l.label === request.body.location);
       if (!loc) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Location "${request.body.location}" not found. Configure it first.` } });
+        throw validationError(`Location "${request.body.location}" not found. Configure it first.`);
       }
       resolvedLocation = loc;
     }
     if (request.body?.allLocations) {
       if (projectLocations.length === 0) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: "No locations configured for this project" } });
+        throw validationError("No locations configured for this project");
       }
       const newRuns = [];
       for (const loc of projectLocations) {
@@ -2502,10 +2507,7 @@ async function runRoutes(app, opts) {
       trigger,
       location: locationLabel
     });
-    if (queueResult.conflict) {
-      const err = runInProgress(project.name);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (queueResult.conflict) throw runInProgress(project.name);
     const runId = queueResult.runId;
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -2521,8 +2523,7 @@ async function runRoutes(app, opts) {
     return reply.status(201).send(formatRun(run));
   });
   app.get("/projects/:name/runs", async (request, reply) => {
-    const project = resolveProjectSafe3(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const parsedLimit = parseInt(request.query.limit ?? "", 10);
     const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? void 0 : parsedLimit;
     const rows = limit == null ? app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(asc(runs.createdAt)).all() : app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(desc(runs.createdAt)).limit(limit).all().reverse();
@@ -2538,10 +2539,7 @@ async function runRoutes(app, opts) {
       return reply.status(207).send([]);
     }
     const kind = request.body?.kind ?? "answer-visibility";
-    if (kind !== "answer-visibility") {
-      const err = unsupportedKind(kind);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (kind !== "answer-visibility") throw unsupportedKind(kind);
     const rawProviders = request.body?.providers;
     if (rawProviders?.length) {
       const normalized = rawProviders.map((p) => p.trim().toLowerCase()).filter(Boolean);
@@ -2549,11 +2547,10 @@ async function runRoutes(app, opts) {
       if (validNames.length) {
         const invalid = normalized.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: invalid,
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
       rawProviders.splice(0, rawProviders.length, ...normalized);
@@ -2590,15 +2587,9 @@ async function runRoutes(app, opts) {
   });
   app.post("/runs/:id/cancel", async (request, reply) => {
     const run = app.db.select().from(runs).where(eq7(runs.id, request.params.id)).get();
-    if (!run) {
-      const err = notFound("Run", request.params.id);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (!run) throw notFound("Run", request.params.id);
     const terminalStatuses = /* @__PURE__ */ new Set(["completed", "partial", "failed", "cancelled"]);
-    if (terminalStatuses.has(run.status)) {
-      const err = runNotCancellable(run.id, run.status);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (terminalStatuses.has(run.status)) throw runNotCancellable(run.id, run.status);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.update(runs).set({ status: "cancelled", finishedAt: now, error: "Cancelled by user" }).where(eq7(runs.id, run.id)).run();
     writeAuditLog(app.db, {
@@ -2613,9 +2604,12 @@ async function runRoutes(app, opts) {
   });
   app.get("/runs/:id", async (request, reply) => {
     const run = app.db.select().from(runs).where(eq7(runs.id, request.params.id)).get();
-    if (!run) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `Run '${request.params.id}' not found` } });
-    }
+    if (!run) throw notFound("Run", request.params.id);
+    const project = app.db.select({
+      displayName: projects.displayName,
+      canonicalDomain: projects.canonicalDomain,
+      ownedDomains: projects.ownedDomains
+    }).from(projects).where(eq7(projects.id, run.projectId)).get();
     const snapshots = app.db.select({
       id: querySnapshots.id,
       runId: querySnapshots.runId,
@@ -2624,6 +2618,7 @@ async function runRoutes(app, opts) {
       provider: querySnapshots.provider,
       model: querySnapshots.model,
       citationState: querySnapshots.citationState,
+      answerMentioned: querySnapshots.answerMentioned,
       answerText: querySnapshots.answerText,
       citedDomains: querySnapshots.citedDomains,
       competitorOverlap: querySnapshots.competitorOverlap,
@@ -2636,6 +2631,7 @@ async function runRoutes(app, opts) {
       ...formatRun(run),
       snapshots: snapshots.map((s) => {
         const rawParsed = parseSnapshotRawResponse(s.rawResponse);
+        const answerMentioned = project ? resolveSnapshotAnswerMentioned(s, project) : s.answerMentioned ?? false;
         return {
           id: s.id,
           runId: s.runId,
@@ -2643,10 +2639,12 @@ async function runRoutes(app, opts) {
           keyword: s.keyword,
           provider: s.provider,
           citationState: s.citationState,
+          answerMentioned,
+          visibilityState: project ? resolveSnapshotVisibilityState(s, project) : answerMentioned ? "visible" : "not-visible",
           answerText: s.answerText,
-          citedDomains: tryParseJson(s.citedDomains, []),
-          competitorOverlap: tryParseJson(s.competitorOverlap, []),
-          recommendedCompetitors: tryParseJson(s.recommendedCompetitors, []),
+          citedDomains: parseJsonColumn(s.citedDomains, []),
+          competitorOverlap: parseJsonColumn(s.competitorOverlap, []),
+          recommendedCompetitors: parseJsonColumn(s.recommendedCompetitors, []),
           model: s.model ?? rawParsed.model,
           location: s.location,
           groundingSources: rawParsed.groundingSources,
@@ -2672,32 +2670,13 @@ function formatRun(row) {
   };
 }
 function parseSnapshotRawResponse(raw) {
-  const parsed = tryParseJson(raw ?? "{}", {});
+  const parsed = parseJsonColumn(raw, {});
   return {
     groundingSources: parsed.groundingSources ?? [],
     searchQueries: parsed.searchQueries ?? [],
     model: parsed.model ?? null
   };
 }
-function tryParseJson(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-function resolveProjectSafe3(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/apply.ts
 import crypto10 from "crypto";
@@ -2955,10 +2934,9 @@ async function applyRoutes(app, opts) {
   app.post("/apply", async (request, reply) => {
     const parsed = projectConfigSchema.safeParse(request.body);
     if (!parsed.success) {
-      const err = validationError("Invalid project config", {
+      throw validationError("Invalid project config", {
         issues: parsed.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const config = parsed.data;
     const validNames = opts?.validProviderNames ?? [];
@@ -2970,70 +2948,104 @@ async function applyRoutes(app, opts) {
       if (allProviders.length) {
         const invalid = allProviders.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${[...new Set(invalid)].join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${[...new Set(invalid)].join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: [...new Set(invalid)],
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
     }
+    let resolvedSchedule = null;
+    let deleteSchedule = false;
+    if (config.spec.schedule) {
+      const schedSpec = config.spec.schedule;
+      let cronExpr;
+      let preset = null;
+      if (schedSpec.preset) {
+        preset = schedSpec.preset;
+        try {
+          cronExpr = resolvePreset(schedSpec.preset);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw validationError(msg);
+        }
+      } else if (schedSpec.cron) {
+        cronExpr = schedSpec.cron;
+        if (!validateCron(cronExpr)) throw validationError(`Invalid cron expression in schedule: ${cronExpr}`);
+      } else {
+        throw validationError('Schedule requires either "preset" or "cron"');
+      }
+      const timezone = schedSpec.timezone ?? "UTC";
+      if (!isValidTimezone(timezone)) throw validationError(`Invalid timezone: ${timezone}`);
+      resolvedSchedule = { cronExpr, preset, timezone };
+    } else {
+      deleteSchedule = true;
+    }
+    const rawSpec = request.body?.spec ?? {};
+    const hasNotifications = "notifications" in rawSpec;
+    if (hasNotifications) {
+      for (const notif of config.spec.notifications) {
+        const urlCheck = await resolveWebhookTarget(notif.url ?? "");
+        if (!urlCheck.ok) throw validationError(`Notification URL invalid: ${urlCheck.message}`);
+      }
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const name = config.metadata.name;
-    const existing = app.db.select().from(projects).where(eq8(projects.name, name)).get();
     let projectId;
-    if (existing) {
-      projectId = existing.id;
-      app.db.update(projects).set({
-        displayName: config.spec.displayName,
-        canonicalDomain: config.spec.canonicalDomain,
-        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
-        country: config.spec.country,
-        language: config.spec.language,
-        labels: JSON.stringify(config.metadata.labels),
-        providers: JSON.stringify(config.spec.providers ?? []),
-        locations: JSON.stringify(config.spec.locations ?? []),
-        defaultLocation: config.spec.defaultLocation ?? null,
-        configSource: "config-file",
-        configRevision: existing.configRevision + 1,
-        updatedAt: now
-      }).where(eq8(projects.id, existing.id)).run();
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "project.applied",
-        entityType: "project",
-        entityId: projectId
-      });
-    } else {
-      projectId = crypto10.randomUUID();
-      app.db.insert(projects).values({
-        id: projectId,
-        name,
-        displayName: config.spec.displayName,
-        canonicalDomain: config.spec.canonicalDomain,
-        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
-        country: config.spec.country,
-        language: config.spec.language,
-        tags: "[]",
-        labels: JSON.stringify(config.metadata.labels),
-        providers: JSON.stringify(config.spec.providers ?? []),
-        locations: JSON.stringify(config.spec.locations ?? []),
-        defaultLocation: config.spec.defaultLocation ?? null,
-        configSource: "config-file",
-        configRevision: 1,
-        createdAt: now,
-        updatedAt: now
-      }).run();
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "project.created",
-        entityType: "project",
-        entityId: projectId
-      });
-    }
+    let scheduleAction = null;
     app.db.transaction((tx) => {
+      const existing = tx.select().from(projects).where(eq8(projects.name, name)).get();
+      if (existing) {
+        projectId = existing.id;
+        tx.update(projects).set({
+          displayName: config.spec.displayName,
+          canonicalDomain: config.spec.canonicalDomain,
+          ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
+          country: config.spec.country,
+          language: config.spec.language,
+          labels: JSON.stringify(config.metadata.labels),
+          providers: JSON.stringify(config.spec.providers ?? []),
+          locations: JSON.stringify(config.spec.locations ?? []),
+          defaultLocation: config.spec.defaultLocation ?? null,
+          configSource: "config-file",
+          configRevision: existing.configRevision + 1,
+          updatedAt: now
+        }).where(eq8(projects.id, existing.id)).run();
+        writeAuditLog(tx, {
+          projectId,
+          actor: "api",
+          action: "project.applied",
+          entityType: "project",
+          entityId: projectId
+        });
+      } else {
+        projectId = crypto10.randomUUID();
+        tx.insert(projects).values({
+          id: projectId,
+          name,
+          displayName: config.spec.displayName,
+          canonicalDomain: config.spec.canonicalDomain,
+          ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
+          country: config.spec.country,
+          language: config.spec.language,
+          tags: "[]",
+          labels: JSON.stringify(config.metadata.labels),
+          providers: JSON.stringify(config.spec.providers ?? []),
+          locations: JSON.stringify(config.spec.locations ?? []),
+          defaultLocation: config.spec.defaultLocation ?? null,
+          configSource: "config-file",
+          configRevision: 1,
+          createdAt: now,
+          updatedAt: now
+        }).run();
+        writeAuditLog(tx, {
+          projectId,
+          actor: "api",
+          action: "project.created",
+          entityType: "project",
+          entityId: projectId
+        });
+      }
       tx.delete(keywords).where(eq8(keywords.projectId, projectId)).run();
       for (const kw of config.spec.keywords) {
         tx.insert(keywords).values({
@@ -3066,98 +3078,63 @@ async function applyRoutes(app, opts) {
         entityType: "competitor",
         diff: { competitors: config.spec.competitors }
       });
-    });
-    if (config.spec.schedule) {
-      const schedSpec = config.spec.schedule;
-      let cronExpr;
-      let preset = null;
-      if (schedSpec.preset) {
-        preset = schedSpec.preset;
-        try {
-          cronExpr = resolvePreset(schedSpec.preset);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: msg } });
+      if (resolvedSchedule) {
+        const existingSched = tx.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
+        if (existingSched) {
+          tx.update(schedules).set({
+            cronExpr: resolvedSchedule.cronExpr,
+            preset: resolvedSchedule.preset,
+            timezone: resolvedSchedule.timezone,
+            providers: JSON.stringify(config.spec.schedule?.providers ?? []),
+            enabled: 1,
+            updatedAt: now
+          }).where(eq8(schedules.id, existingSched.id)).run();
+        } else {
+          tx.insert(schedules).values({
+            id: crypto10.randomUUID(),
+            projectId,
+            cronExpr: resolvedSchedule.cronExpr,
+            preset: resolvedSchedule.preset,
+            timezone: resolvedSchedule.timezone,
+            enabled: 1,
+            providers: JSON.stringify(config.spec.schedule?.providers ?? []),
+            createdAt: now,
+            updatedAt: now
+          }).run();
         }
-      } else if (schedSpec.cron) {
-        cronExpr = schedSpec.cron;
-        if (!validateCron(cronExpr)) {
-          return reply.status(400).send({
-            error: { code: "VALIDATION_ERROR", message: `Invalid cron expression in schedule: ${cronExpr}` }
-          });
+        scheduleAction = "upsert";
+      } else if (deleteSchedule) {
+        const existingSched = tx.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
+        if (existingSched) {
+          tx.delete(schedules).where(eq8(schedules.projectId, projectId)).run();
+          scheduleAction = "delete";
         }
-      } else {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: 'Schedule requires either "preset" or "cron"' }
-        });
-      }
-      const timezone = schedSpec.timezone ?? "UTC";
-      if (!isValidTimezone(timezone)) {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid timezone: ${timezone}` }
-        });
-      }
-      const existingSched = app.db.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
-      if (existingSched) {
-        app.db.update(schedules).set({
-          cronExpr,
-          preset,
-          timezone,
-          providers: JSON.stringify(schedSpec.providers ?? []),
-          enabled: 1,
-          updatedAt: now
-        }).where(eq8(schedules.id, existingSched.id)).run();
-      } else {
-        app.db.insert(schedules).values({
-          id: crypto10.randomUUID(),
-          projectId,
-          cronExpr,
-          preset,
-          timezone,
-          enabled: 1,
-          providers: JSON.stringify(schedSpec.providers ?? []),
-          createdAt: now,
-          updatedAt: now
-        }).run();
-      }
-      opts?.onScheduleUpdated?.("upsert", projectId);
-    } else {
-      const existingSched = app.db.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
-      if (existingSched) {
-        app.db.delete(schedules).where(eq8(schedules.projectId, projectId)).run();
-        opts?.onScheduleUpdated?.("delete", projectId);
       }
-    }
-    const rawSpec = request.body?.spec ?? {};
-    if ("notifications" in rawSpec) {
-      for (const notif of config.spec.notifications) {
-        const urlCheck = await resolveWebhookTarget(notif.url ?? "");
-        if (!urlCheck.ok) {
-          return reply.status(400).send({
-            error: { code: "VALIDATION_ERROR", message: `Notification URL invalid: ${urlCheck.message}` }
-          });
+      if (hasNotifications) {
+        tx.delete(notifications).where(eq8(notifications.projectId, projectId)).run();
+        for (const notif of config.spec.notifications) {
+          tx.insert(notifications).values({
+            id: crypto10.randomUUID(),
+            projectId,
+            channel: notif.channel,
+            config: JSON.stringify({ url: notif.url, events: notif.events }),
+            webhookSecret: crypto10.randomBytes(32).toString("hex"),
+            enabled: 1,
+            createdAt: now,
+            updatedAt: now
+          }).run();
         }
-      }
-      app.db.delete(notifications).where(eq8(notifications.projectId, projectId)).run();
-      for (const notif of config.spec.notifications) {
-        app.db.insert(notifications).values({
-          id: crypto10.randomUUID(),
+        writeAuditLog(tx, {
           projectId,
-          channel: notif.channel,
-          config: JSON.stringify({ url: notif.url, events: notif.events }),
-          webhookSecret: crypto10.randomBytes(32).toString("hex"),
-          enabled: 1,
-          createdAt: now,
-          updatedAt: now
-        }).run();
+          actor: "api",
+          action: "notifications.replaced",
+          entityType: "notification",
+          diff: { notifications: config.spec.notifications }
+        });
       }
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "notifications.replaced",
-        entityType: "notification",
-        diff: { notifications: config.spec.notifications }
-      });
+    });
+    if (scheduleAction) {
+      opts?.onScheduleUpdated?.(scheduleAction, projectId);
     }
     if ("google" in rawSpec && config.spec.google?.gsc?.propertyUrl) {
       opts?.onGoogleConnectionPropertyUpdated?.(config.spec.canonicalDomain, "gsc", config.spec.google.gsc.propertyUrl);
@@ -3168,13 +3145,13 @@ async function applyRoutes(app, opts) {
       name: project.name,
       displayName: project.displayName,
       canonicalDomain: project.canonicalDomain,
-      ownedDomains: JSON.parse(project.ownedDomains || "[]"),
+      ownedDomains: parseJsonColumn(project.ownedDomains, []),
       country: project.country,
       language: project.language,
-      tags: JSON.parse(project.tags),
-      labels: JSON.parse(project.labels),
-      providers: JSON.parse(project.providers || "[]"),
-      locations: JSON.parse(project.locations || "[]"),
+      tags: parseJsonColumn(project.tags, []),
+      labels: parseJsonColumn(project.labels, {}),
+      providers: parseJsonColumn(project.providers, []),
+      locations: parseJsonColumn(project.locations, []),
       defaultLocation: project.defaultLocation,
       configSource: project.configSource,
       configRevision: project.configRevision,
@@ -3230,8 +3207,7 @@ function redactNotificationDiff(value) {
 // ../api-routes/src/history.ts
 async function historyRoutes(app) {
   app.get("/projects/:name/history", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(auditLog).where(eq9(auditLog.projectId, project.id)).orderBy(desc2(auditLog.createdAt)).all();
     return reply.send(rows.map(formatAuditEntry));
   });
@@ -3240,8 +3216,7 @@ async function historyRoutes(app) {
     return reply.send(rows.map(formatAuditEntry));
   });
   app.get("/projects/:name/snapshots", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const limit = parseInt(request.query.limit ?? "50", 10);
     const offset = parseInt(request.query.offset ?? "0", 10);
     const projectRuns = app.db.select({ id: runs.id }).from(runs).where(eq9(runs.projectId, project.id)).all();
@@ -3256,6 +3231,7 @@ async function historyRoutes(app) {
       provider: querySnapshots.provider,
       model: querySnapshots.model,
       citationState: querySnapshots.citationState,
+      answerMentioned: querySnapshots.answerMentioned,
       answerText: querySnapshots.answerText,
       citedDomains: querySnapshots.citedDomains,
       competitorOverlap: querySnapshots.competitorOverlap,
@@ -3276,10 +3252,12 @@ async function historyRoutes(app) {
         provider: s.provider,
         model: s.model,
         citationState: s.citationState,
+        answerMentioned: resolveSnapshotAnswerMentioned(s, project),
+        visibilityState: resolveSnapshotVisibilityState(s, project),
         answerText: s.answerText,
-        citedDomains: tryParseJson2(s.citedDomains, []),
-        competitorOverlap: tryParseJson2(s.competitorOverlap, []),
-        recommendedCompetitors: tryParseJson2(s.recommendedCompetitors, []),
+        citedDomains: parseJsonColumn(s.citedDomains, []),
+        competitorOverlap: parseJsonColumn(s.competitorOverlap, []),
+        recommendedCompetitors: parseJsonColumn(s.recommendedCompetitors, []),
         location: s.location,
         createdAt: s.createdAt
       })),
@@ -3287,8 +3265,7 @@ async function historyRoutes(app) {
     });
   });
   app.get("/projects/:name/timeline", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const projectKeywords = app.db.select().from(keywords).where(eq9(keywords.projectId, project.id)).all();
     const projectRuns = app.db.select().from(runs).where(eq9(runs.projectId, project.id)).orderBy(runs.createdAt).all();
     if (projectRuns.length === 0 || projectKeywords.length === 0) {
@@ -3297,12 +3274,16 @@ async function historyRoutes(app) {
     const runIds = new Set(projectRuns.map((r) => r.id));
     const rawSnapshots = app.db.select().from(querySnapshots).where(inArray(querySnapshots.runId, [...runIds])).all();
     const timelineLocationFilter = request.query.location;
-    const allSnapshots = timelineLocationFilter !== void 0 ? rawSnapshots.filter((s) => s.location === (timelineLocationFilter || null)) : rawSnapshots;
+    const filteredSnapshots = timelineLocationFilter !== void 0 ? rawSnapshots.filter((s) => s.location === (timelineLocationFilter || null)) : rawSnapshots;
+    const allSnapshots = filteredSnapshots.map((snapshot) => ({
+      ...snapshot,
+      answerMentioned: resolveSnapshotAnswerMentioned(snapshot, project)
+    }));
     const deduped = /* @__PURE__ */ new Map();
     for (const snap of allSnapshots) {
       const key = `${snap.runId}:${snap.keywordId}`;
       const existing = deduped.get(key);
-      if (!existing || snap.citationState === "cited") {
+      if (!existing || !existing.answerMentioned && snap.answerMentioned || existing.answerMentioned === snap.answerMentioned && snap.citationState === "cited") {
         deduped.set(key, snap);
       }
     }
@@ -3325,8 +3306,10 @@ async function historyRoutes(app) {
       return snaps.map((snap, idx) => {
         const run = projectRuns.find((r) => r.id === snap.runId);
         let transition = snap.citationState === "cited" ? "cited" : "not-cited";
+        let visibilityTransition = snap.answerMentioned ? "visible" : "not-visible";
         if (idx === 0) {
           transition = "new";
+          visibilityTransition = "new";
         } else {
           const prev = snaps[idx - 1];
           if (prev.citationState === "not-cited" && snap.citationState === "cited") {
@@ -3334,12 +3317,20 @@ async function historyRoutes(app) {
           } else if (prev.citationState === "cited" && snap.citationState === "not-cited") {
             transition = "lost";
           }
+          if (!prev.answerMentioned && snap.answerMentioned) {
+            visibilityTransition = "emerging";
+          } else if (prev.answerMentioned && !snap.answerMentioned) {
+            visibilityTransition = "lost";
+          }
         }
         return {
           runId: snap.runId,
           createdAt: run?.createdAt ?? snap.createdAt,
           citationState: snap.citationState,
-          transition
+          transition,
+          answerMentioned: snap.answerMentioned,
+          visibilityState: snap.answerMentioned ? "visible" : "not-visible",
+          visibilityTransition
         };
       });
     }
@@ -3370,31 +3361,48 @@ async function historyRoutes(app) {
     return reply.send(timeline);
   });
   app.get("/projects/:name/snapshots/diff", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const { run1, run2 } = request.query;
     if (!run1 || !run2) {
-      return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: "Both run1 and run2 query params are required" } });
+      throw validationError("Both run1 and run2 query params are required");
     }
     const snaps1 = app.db.select({
       keywordId: querySnapshots.keywordId,
       keyword: keywords.keyword,
-      citationState: querySnapshots.citationState
+      citationState: querySnapshots.citationState,
+      answerMentioned: querySnapshots.answerMentioned,
+      answerText: querySnapshots.answerText
     }).from(querySnapshots).leftJoin(keywords, eq9(querySnapshots.keywordId, keywords.id)).where(eq9(querySnapshots.runId, run1)).all();
     const snaps2 = app.db.select({
       keywordId: querySnapshots.keywordId,
       keyword: keywords.keyword,
-      citationState: querySnapshots.citationState
+      citationState: querySnapshots.citationState,
+      answerMentioned: querySnapshots.answerMentioned,
+      answerText: querySnapshots.answerText
     }).from(querySnapshots).leftJoin(keywords, eq9(querySnapshots.keywordId, keywords.id)).where(eq9(querySnapshots.runId, run2)).all();
     const map1 = /* @__PURE__ */ new Map();
     for (const s of snaps1) {
+      const resolved = {
+        ...s,
+        resolvedAnswerMentioned: resolveSnapshotAnswerMentioned(s, project),
+        resolvedVisibilityState: resolveSnapshotVisibilityState(s, project)
+      };
       const existing = map1.get(s.keywordId);
-      if (!existing || s.citationState === "cited") map1.set(s.keywordId, s);
+      if (!existing || !existing.resolvedAnswerMentioned && resolved.resolvedAnswerMentioned || existing.resolvedAnswerMentioned === resolved.resolvedAnswerMentioned && resolved.citationState === "cited") {
+        map1.set(s.keywordId, resolved);
+      }
     }
     const map2 = /* @__PURE__ */ new Map();
     for (const s of snaps2) {
+      const resolved = {
+        ...s,
+        resolvedAnswerMentioned: resolveSnapshotAnswerMentioned(s, project),
+        resolvedVisibilityState: resolveSnapshotVisibilityState(s, project)
+      };
       const existing = map2.get(s.keywordId);
-      if (!existing || s.citationState === "cited") map2.set(s.keywordId, s);
+      if (!existing || !existing.resolvedAnswerMentioned && resolved.resolvedAnswerMentioned || existing.resolvedAnswerMentioned === resolved.resolvedAnswerMentioned && resolved.citationState === "cited") {
+        map2.set(s.keywordId, resolved);
+      }
     }
     const allKeywordIds = /* @__PURE__ */ new Set([...map1.keys(), ...map2.keys()]);
     const diff = [...allKeywordIds].map((kwId) => {
@@ -3405,7 +3413,12 @@ async function historyRoutes(app) {
         keyword: s2?.keyword ?? s1?.keyword ?? null,
         run1State: s1?.citationState ?? null,
         run2State: s2?.citationState ?? null,
-        changed: (s1?.citationState ?? null) !== (s2?.citationState ?? null)
+        run1AnswerMentioned: s1?.resolvedAnswerMentioned ?? null,
+        run2AnswerMentioned: s2?.resolvedAnswerMentioned ?? null,
+        run1VisibilityState: s1?.resolvedVisibilityState ?? null,
+        run2VisibilityState: s2?.resolvedVisibilityState ?? null,
+        changed: (s1?.citationState ?? null) !== (s2?.citationState ?? null),
+        visibilityChanged: (s1?.resolvedAnswerMentioned ?? null) !== (s2?.resolvedAnswerMentioned ?? null)
       };
     });
     return reply.send({ run1, run2, diff });
@@ -3419,36 +3432,16 @@ function formatAuditEntry(row) {
     action: row.action,
     entityType: row.entityType,
     entityId: row.entityId,
-    diff: row.diff ? row.entityType === "notification" ? redactNotificationDiff(tryParseJson2(row.diff, null)) : tryParseJson2(row.diff, null) : null,
+    diff: row.diff ? row.entityType === "notification" ? redactNotificationDiff(parseJsonColumn(row.diff, null)) : parseJsonColumn(row.diff, null) : null,
     createdAt: row.createdAt
   };
 }
-function tryParseJson2(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-function resolveProjectSafe4(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/analytics.ts
 import { eq as eq10, desc as desc3, inArray as inArray2 } from "drizzle-orm";
 async function analyticsRoutes(app) {
   app.get("/projects/:name/analytics/metrics", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const projectRuns = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
@@ -3488,8 +3481,7 @@ async function analyticsRoutes(app) {
     return reply.send({ window, buckets, overall, byProvider, trend, keywordChanges });
   });
   app.get("/projects/:name/analytics/gaps", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const latestRun = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc3(runs.createdAt)).all().find((r) => r.status === "completed" || r.status === "partial");
@@ -3537,7 +3529,7 @@ async function analyticsRoutes(app) {
       const citedProviders = kwSnapshots.filter((s) => s.citationState === "cited").map((s) => s.provider);
       const competitorsCiting = /* @__PURE__ */ new Set();
       for (const s of kwSnapshots) {
-        const overlap = tryParseJson3(s.competitorOverlap, []);
+        const overlap = parseJsonColumn(s.competitorOverlap, []);
         for (const c of overlap) competitorsCiting.add(c);
       }
       let category;
@@ -3570,8 +3562,7 @@ async function analyticsRoutes(app) {
     return reply.send({ cited, gap, uncited, runId: latestRun.id, window });
   });
   app.get("/projects/:name/analytics/sources", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const windowRuns = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc3(runs.createdAt)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
@@ -3607,26 +3598,6 @@ async function analyticsRoutes(app) {
     return reply.send({ overall, byKeyword, runId: latestRunId, window });
   });
 }
-function resolveProjectSafe5(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
-function tryParseJson3(value, fallback) {
-  if (!value) return fallback;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
 var PROVIDER_INFRA_DOMAINS = /* @__PURE__ */ new Set([
   "vertexaisearch.cloud.google.com",
   "openai.com",
@@ -3644,7 +3615,7 @@ function isProviderInfraDomain(uri) {
   return false;
 }
 function parseGroundingSources(rawResponse) {
-  const parsed = tryParseJson3(rawResponse, {});
+  const parsed = parseJsonColumn(rawResponse, {});
   const sources = parsed.groundingSources;
   if (!Array.isArray(sources)) return [];
   return sources.filter(
@@ -6014,34 +5985,29 @@ import crypto11 from "crypto";
 import { eq as eq11 } from "drizzle-orm";
 async function scheduleRoutes(app, opts) {
   app.put("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const parsedBody = scheduleUpsertRequestSchema.safeParse(request.body);
     if (!parsedBody.success) {
-      const err = validationError("Invalid schedule payload", {
+      throw validationError("Invalid schedule payload", {
         issues: parsedBody.error.issues.map((issue) => ({
           path: issue.path.join("."),
           message: issue.message
         }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const { preset, cron: cron2, timezone, providers, enabled } = parsedBody.data;
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && providers?.length) {
       const invalid = providers.filter((p) => !validNames.includes(p));
       if (invalid.length) {
-        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+        throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
           invalidProviders: invalid,
           validProviders: validNames
         });
-        return reply.status(err.statusCode).send(err.toJSON());
       }
     }
     if (!isValidTimezone(timezone)) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Invalid timezone: ${timezone}` }
-      });
+      throw validationError(`Invalid timezone: ${timezone}`);
     }
     let cronExpr;
     if (preset) {
@@ -6049,14 +6015,12 @@ async function scheduleRoutes(app, opts) {
         cronExpr = resolvePreset(preset);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: msg } });
+        throw validationError(msg);
       }
     } else {
       cronExpr = cron2;
       if (!validateCron(cronExpr)) {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid cron expression: ${cronExpr}` }
-        });
+        throw validationError(`Invalid cron expression: ${cronExpr}`);
       }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -6096,20 +6060,18 @@ async function scheduleRoutes(app, opts) {
     return reply.status(existing ? 200 : 201).send(formatSchedule(schedule));
   });
   app.get("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const schedule = app.db.select().from(schedules).where(eq11(schedules.projectId, project.id)).get();
     if (!schedule) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `No schedule for project '${request.params.name}'` } });
+      throw notFound("Schedule", request.params.name);
     }
     return reply.send(formatSchedule(schedule));
   });
   app.delete("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const schedule = app.db.select().from(schedules).where(eq11(schedules.projectId, project.id)).get();
     if (!schedule) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `No schedule for project '${request.params.name}'` } });
+      throw notFound("Schedule", request.params.name);
     }
     app.db.delete(schedules).where(eq11(schedules.id, schedule.id)).run();
     writeAuditLog(app.db, {
@@ -6131,25 +6093,13 @@ function formatSchedule(row) {
     preset: row.preset,
     timezone: row.timezone,
     enabled: row.enabled === 1,
-    providers: JSON.parse(row.providers),
+    providers: parseJsonColumn(row.providers, []),
     lastRunAt: row.lastRunAt,
     nextRunAt: row.nextRunAt,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
   };
 }
-function resolveProjectSafe6(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/notifications.ts
 import crypto12 from "crypto";
@@ -6160,30 +6110,15 @@ async function notificationRoutes(app) {
     return reply.send(VALID_EVENTS);
   });
   app.post("/projects/:name/notifications", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const { channel, url, events } = request.body ?? {};
-    if (channel !== "webhook") {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: 'Only "webhook" channel is supported' }
-      });
-    }
+    if (channel !== "webhook") throw validationError('Only "webhook" channel is supported');
     const urlCheck = await resolveWebhookTarget(url ?? "");
-    if (!urlCheck.ok) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: urlCheck.message }
-      });
-    }
-    if (!events?.length) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: '"events" must be a non-empty array' }
-      });
-    }
+    if (!urlCheck.ok) throw validationError(urlCheck.message);
+    if (!events?.length) throw validationError('"events" must be a non-empty array');
     const invalid = events.filter((e) => !VALID_EVENTS.includes(e));
     if (invalid.length) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Invalid event(s): ${invalid.join(", ")}. Must be one of: ${VALID_EVENTS.join(", ")}` }
-      });
+      throw validationError(`Invalid event(s): ${invalid.join(", ")}. Must be one of: ${VALID_EVENTS.join(", ")}`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const id = crypto12.randomUUID();
@@ -6212,19 +6147,15 @@ async function notificationRoutes(app) {
     });
   });
   app.get("/projects/:name/notifications", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(notifications).where(eq12(notifications.projectId, project.id)).all();
     return reply.send(rows.map(formatNotification));
   });
   app.delete("/projects/:name/notifications/:id", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const notification = app.db.select().from(notifications).where(eq12(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
-      return reply.status(404).send({
-        error: { code: "NOT_FOUND", message: `Notification '${request.params.id}' not found` }
-      });
+      throw notFound("Notification", request.params.id);
     }
     app.db.delete(notifications).where(eq12(notifications.id, notification.id)).run();
     writeAuditLog(app.db, {
@@ -6237,21 +6168,14 @@ async function notificationRoutes(app) {
     return reply.status(204).send();
   });
   app.post("/projects/:name/notifications/:id/test", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const notification = app.db.select().from(notifications).where(eq12(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
-      return reply.status(404).send({
-        error: { code: "NOT_FOUND", message: `Notification '${request.params.id}' not found` }
-      });
+      throw notFound("Notification", request.params.id);
     }
-    const config = JSON.parse(notification.config);
+    const config = parseJsonColumn(notification.config, { url: "", events: [] });
     const urlCheck = await resolveWebhookTarget(config.url);
-    if (!urlCheck.ok) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Stored webhook URL is invalid: ${urlCheck.message}` }
-      });
-    }
+    if (!urlCheck.ok) throw validationError(`Stored webhook URL is invalid: ${urlCheck.message}`);
     const payload = {
       source: "canonry",
       event: "run.completed",
@@ -6274,14 +6198,12 @@ async function notificationRoutes(app) {
       entityId: notification.id,
       diff: { status, error }
     });
-    if (error) {
-      return reply.status(502).send({ error: { code: "DELIVERY_FAILED", message: error } });
-    }
+    if (error) throw deliveryFailed(error);
     return reply.send({ status, ok: status >= 200 && status < 300 });
   });
 }
 function formatNotification(row) {
-  const config = JSON.parse(row.config);
+  const config = parseJsonColumn(row.config, { url: "", events: [] });
   const redacted = redactNotificationUrl(config.url);
   return {
     id: row.id,
@@ -6296,22 +6218,10 @@ function formatNotification(row) {
     updatedAt: row.updatedAt
   };
 }
-function resolveProjectSafe7(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/google.ts
 import crypto13 from "crypto";
-import { eq as eq13, and as and3, desc as desc4, sql as sql2 } from "drizzle-orm";
+import { eq as eq13, and as and2, desc as desc4, sql as sql3 } from "drizzle-orm";
 
 // ../integration-google/src/constants.ts
 var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
@@ -6758,11 +6668,11 @@ async function googleRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const { startDate, endDate, query, page, limit } = request.query;
     const conditions = [eq13(gscSearchData.projectId, project.id)];
-    if (startDate) conditions.push(sql2`${gscSearchData.date} >= ${startDate}`);
-    if (endDate) conditions.push(sql2`${gscSearchData.date} <= ${endDate}`);
-    if (query) conditions.push(sql2`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
-    if (page) conditions.push(sql2`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
-    const rows = app.db.select().from(gscSearchData).where(and3(...conditions)).orderBy(desc4(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
+    if (startDate) conditions.push(sql3`${gscSearchData.date} >= ${startDate}`);
+    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(and2(...conditions)).orderBy(desc4(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
     return rows.map((r) => ({
       date: r.date,
       query: r.query,
@@ -6840,7 +6750,7 @@ async function googleRoutes(app, opts) {
     const { url, limit } = request.query;
     const conditions = [eq13(gscUrlInspections.projectId, project.id)];
     if (url) conditions.push(eq13(gscUrlInspections.url, url));
-    const rows = app.db.select().from(gscUrlInspections).where(and3(...conditions)).orderBy(desc4(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
+    const rows = app.db.select().from(gscUrlInspections).where(and2(...conditions)).orderBy(desc4(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
     return rows.map((r) => ({
       id: r.id,
       url: r.url,
@@ -7212,7 +7122,7 @@ async function googleRoutes(app, opts) {
 
 // ../api-routes/src/bing.ts
 import crypto14 from "crypto";
-import { eq as eq14, and as and4, desc as desc5 } from "drizzle-orm";
+import { eq as eq14, and as and3, desc as desc5 } from "drizzle-orm";
 
 // ../integration-bing/src/constants.ts
 var BING_WMT_API_BASE = "https://ssl.bing.com/webmaster/api.svc/json";
@@ -7511,7 +7421,7 @@ async function bingRoutes(app, opts) {
     if (!store) return;
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
-    const whereClause = url ? and4(eq14(bingUrlInspections.projectId, project.id), eq14(bingUrlInspections.url, url)) : eq14(bingUrlInspections.projectId, project.id);
+    const whereClause = url ? and3(eq14(bingUrlInspections.projectId, project.id), eq14(bingUrlInspections.url, url)) : eq14(bingUrlInspections.projectId, project.id);
     const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc5(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
     return filtered.map((r) => ({
       id: r.id,
@@ -7701,7 +7611,7 @@ async function bingRoutes(app, opts) {
 import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
-import { eq as eq15, and as and5 } from "drizzle-orm";
+import { eq as eq15, and as and4 } from "drizzle-orm";
 function getScreenshotDir() {
   return path2.join(os2.homedir(), ".canonry", "screenshots");
 }
@@ -7774,7 +7684,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(eq15(runs.id, runId), eq15(runs.projectId, project.id))).get();
+      const run = app.db.select().from(runs).where(and4(eq15(runs.id, runId), eq15(runs.projectId, project.id))).get();
       if (!run) {
         const err = notFound("Run", runId);
         return reply.code(err.statusCode).send(err.toJSON());
@@ -7871,7 +7781,7 @@ async function cdpRoutes(app, opts) {
 
 // ../api-routes/src/ga.ts
 import crypto16 from "crypto";
-import { eq as eq16, desc as desc6, and as and6, sql as sql3 } from "drizzle-orm";
+import { eq as eq16, desc as desc6, and as and5, sql as sql4 } from "drizzle-orm";
 
 // ../integration-google-analytics/src/ga4-client.ts
 import crypto15 from "crypto";
@@ -8351,10 +8261,10 @@ async function ga4Routes(app, opts) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
       tx.delete(gaTrafficSnapshots).where(
-        and6(
+        and5(
           eq16(gaTrafficSnapshots.projectId, project.id),
-          sql3`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
-          sql3`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
+          sql4`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
+          sql4`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
         )
       ).run();
       if (rows.length > 0) {
@@ -8372,10 +8282,10 @@ async function ga4Routes(app, opts) {
         }
       }
       tx.delete(gaAiReferrals).where(
-        and6(
+        and5(
           eq16(gaAiReferrals.projectId, project.id),
-          sql3`${gaAiReferrals.date} >= ${summary.periodStart}`,
-          sql3`${gaAiReferrals.date} <= ${summary.periodEnd}`
+          sql4`${gaAiReferrals.date} >= ${summary.periodStart}`,
+          sql4`${gaAiReferrals.date} <= ${summary.periodEnd}`
         )
       ).run();
       if (aiReferrals.length > 0) {
@@ -8436,16 +8346,16 @@ async function ga4Routes(app, opts) {
     }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).get();
     const rows = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql3`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql3`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
+      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql4`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
     const aiReferrals = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
-      sessions: sql3`SUM(${gaAiReferrals.sessions})`,
-      users: sql3`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium).orderBy(sql3`SUM(${gaAiReferrals.sessions}) DESC`).all();
+      sessions: sql4`SUM(${gaAiReferrals.sessions})`,
+      users: sql4`SUM(${gaAiReferrals.users})`
+    }).from(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium).orderBy(sql4`SUM(${gaAiReferrals.sessions}) DESC`).all();
     const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).orderBy(desc6(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       totalSessions: summary?.totalSessions ?? 0,
@@ -8477,10 +8387,10 @@ async function ga4Routes(app, opts) {
     }
     const trafficPages = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql3`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql3`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
+      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql4`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
     return {
       pages: trafficPages.map((r) => ({
         landingPage: r.landingPage,
@@ -9165,12 +9075,12 @@ var CANONRY_SCHEMA_START = "<!-- canonry:schema:start -->";
 var CANONRY_SCHEMA_END = "<!-- canonry:schema:end -->";
 function stripCanonrySchema(content) {
   const regex = new RegExp(
-    `${escapeRegExp(CANONRY_SCHEMA_START)}[\\s\\S]*?${escapeRegExp(CANONRY_SCHEMA_END)}`,
+    `${escapeRegExp2(CANONRY_SCHEMA_START)}[\\s\\S]*?${escapeRegExp2(CANONRY_SCHEMA_END)}`,
     "g"
   );
   return content.replace(regex, "").replace(/\n{3,}/g, "\n\n").trim();
 }
-function escapeRegExp(str) {
+function escapeRegExp2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function injectCanonrySchema(content, schemas) {
@@ -9277,7 +9187,7 @@ async function getSchemaStatus(connection, env) {
     const thirdPartySchemas = [];
     if (hasCanonryMarker) {
       const markerRegex = new RegExp(
-        `${escapeRegExp(CANONRY_SCHEMA_START)}([\\s\\S]*?)${escapeRegExp(CANONRY_SCHEMA_END)}`
+        `${escapeRegExp2(CANONRY_SCHEMA_START)}([\\s\\S]*?)${escapeRegExp2(CANONRY_SCHEMA_END)}`
       );
       const match = markerRegex.exec(rawContent);
       if (match?.[1]) {
@@ -12186,7 +12096,7 @@ import crypto18 from "crypto";
 import fs4 from "fs";
 import path5 from "path";
 import os4 from "os";
-import { and as and7, eq as eq17, inArray as inArray3 } from "drizzle-orm";
+import { and as and6, eq as eq17, inArray as inArray3 } from "drizzle-orm";
 
 // src/logger.ts
 var IS_TTY = process.stdout.isTTY === true;
@@ -12336,7 +12246,7 @@ 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(and7(eq17(runs.id, runId), eq17(runs.status, "queued"))).run();
+        this.db.update(runs).set({ status: "running", startedAt: now }).where(and6(eq17(runs.id, runId), eq17(runs.status, "queued"))).run();
       }
       this.throwIfRunCancelled(runId);
       const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
@@ -12422,6 +12332,11 @@ var JobRunner = class {
             const normalized = adapter.normalizeResult(raw);
             log.info("query.result", { runId, provider: providerName, keyword: kw.keyword, citedDomains: normalized.citedDomains, groundingSources: normalized.groundingSources.map((s) => s.uri), matchDomains: allDomains });
             const citationState = determineCitationState(normalized, allDomains);
+            const answerMentioned = determineAnswerMentioned(
+              normalized.answerText,
+              project.displayName,
+              allDomains
+            );
             const overlap = computeCompetitorOverlap(normalized, competitorDomains);
             const extractedCompetitors = extractRecommendedCompetitors(
               normalized.answerText,
@@ -12444,6 +12359,7 @@ var JobRunner = class {
                 provider: providerName,
                 model: raw.model,
                 citationState,
+                answerMentioned,
                 answerText: normalized.answerText,
                 citedDomains: JSON.stringify(normalized.citedDomains),
                 competitorOverlap: JSON.stringify(overlap),
@@ -12466,6 +12382,7 @@ var JobRunner = class {
                 provider: providerName,
                 model: raw.model,
                 citationState,
+                answerMentioned,
                 answerText: normalized.answerText,
                 citedDomains: JSON.stringify(normalized.citedDomains),
                 competitorOverlap: JSON.stringify(overlap),
@@ -12481,7 +12398,7 @@ var JobRunner = class {
               }).run();
             }
             totalSnapshotsInserted++;
-            log.info("query.citation", { runId, provider: providerName, keyword: kw.keyword, citationState });
+            log.info("query.citation", { runId, provider: providerName, keyword: kw.keyword, citationState, answerMentioned });
           });
         } catch (err) {
           if (err instanceof RunCancelledError) {
@@ -12787,7 +12704,7 @@ function matchesBrandKey(candidateKey, brandKeys) {
 
 // src/gsc-sync.ts
 import crypto19 from "crypto";
-import { eq as eq18, and as and8, sql as sql4 } from "drizzle-orm";
+import { eq as eq18, and as and7, sql as sql5 } from "drizzle-orm";
 var log2 = createLogger("GscSync");
 function formatDate2(d) {
   return d.toISOString().split("T")[0];
@@ -12839,10 +12756,10 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     log2.info("fetch.complete", { runId, projectId, rowCount: rows.length });
     db.delete(gscSearchData).where(
-      and8(
+      and7(
         eq18(gscSearchData.projectId, projectId),
-        sql4`${gscSearchData.date} >= ${startDate}`,
-        sql4`${gscSearchData.date} <= ${endDate}`
+        sql5`${gscSearchData.date} >= ${startDate}`,
+        sql5`${gscSearchData.date} <= ${endDate}`
       )
     ).run();
     const batchSize = 500;
@@ -12928,7 +12845,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = formatDate2(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and8(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and7(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto19.randomUUID(),
       projectId,
@@ -12951,7 +12868,7 @@ async function executeGscSync(db, runId, projectId, opts) {
 
 // src/gsc-inspect-sitemap.ts
 import crypto20 from "crypto";
-import { eq as eq19, and as and9 } from "drizzle-orm";
+import { eq as eq19, and as and8 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var LOC_REGEX = /<loc>\s*([^<]+?)\s*<\/loc>/gi;
@@ -13115,7 +13032,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and9(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and8(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto20.randomUUID(),
       projectId,
@@ -13308,7 +13225,7 @@ var Scheduler = class {
 };
 
 // src/notifier.ts
-import { eq as eq21, desc as desc7, and as and10, or as or2 } from "drizzle-orm";
+import { eq as eq21, desc as desc7, and as and9, or as or2 } from "drizzle-orm";
 import crypto21 from "crypto";
 var log5 = createLogger("Notifier");
 var Notifier = class {
@@ -13372,7 +13289,7 @@ var Notifier = class {
   }
   computeTransitions(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
-      and10(
+      and9(
         eq21(runs.projectId, projectId),
         or2(eq21(runs.status, "completed"), eq21(runs.status, "partial"))
       )
@@ -13807,11 +13724,12 @@ var SnapshotService = class {
               manualCompetitors: ctx.manualCompetitors,
               targetDomain: ctx.domain
             });
+            const answerVisibilityDomains = [ctx.domain];
             return {
               provider: provider.adapter.name,
               displayName: provider.adapter.displayName,
               model: raw.model,
-              mentioned: mentionsTargetCompany(normalized.answerText, ctx.companyName, ctx.domain),
+              mentioned: determineAnswerMentioned(normalized.answerText, ctx.companyName, answerVisibilityDomains),
               cited: citesTargetDomain(normalized.citedDomains, normalized.groundingSources, ctx.domain),
               describedAccurately: "unknown",
               accuracyNotes: null,
@@ -14068,26 +13986,6 @@ function buildFallbackRecommendedActions(audit) {
   ];
   return uniqueStrings([...weakestFactors, ...defaults]).slice(0, 4);
 }
-function mentionsTargetCompany(answerText, companyName, domain) {
-  const haystack = normalizeText(answerText);
-  if (!haystack) return false;
-  const fullName = normalizeText(companyName);
-  if (fullName && haystack.includes(fullName)) {
-    return true;
-  }
-  const targetTokens = uniqueStrings([
-    ...extractDistinctiveTokens(companyName),
-    ...extractDistinctiveTokens(extractHostname2(domain).split(".")[0] ?? "")
-  ]);
-  if (targetTokens.length === 0) return false;
-  let matches = 0;
-  for (const token of targetTokens) {
-    if (new RegExp(`\\b${escapeRegExp2(token)}\\b`, "i").test(answerText)) {
-      matches++;
-    }
-  }
-  return matches >= Math.min(2, targetTokens.length) || matches >= 1 && targetTokens.length === 1;
-}
 function citesTargetDomain(citedDomains, groundingSources, targetDomain) {
   const normalizedTarget = extractHostname2(targetDomain);
   for (const domain of citedDomains) {
@@ -14158,9 +14056,6 @@ function parseJsonObject(input) {
   const json = start >= 0 && end >= start ? candidate.slice(start, end + 1) : candidate;
   return JSON.parse(json);
 }
-function normalizeText(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-}
 function normalizeStringList(values) {
   const items = values.flatMap((value) => value.split(","));
   return uniqueStrings(
@@ -14191,9 +14086,6 @@ function domainMatches2(candidate, target) {
   const normalizedTarget = normalizeDomain(target);
   return normalizedCandidate === normalizedTarget || normalizedCandidate.endsWith(`.${normalizedTarget}`);
 }
-function extractDistinctiveTokens(value) {
-  return normalizeText(value).split(" ").filter((token) => token.length >= 4).filter((token) => !["llc", "inc", "corp", "company", "group", "services", "solutions", "agency"].includes(token));
-}
 function isDomainLike(value) {
   const normalized = normalizeDomain(value);
   return normalized.includes(".") && !normalized.includes(" ");
@@ -14202,9 +14094,6 @@ function clipText(value, length) {
   if (value.length <= length) return value;
   return `${value.slice(0, length - 3)}...`;
 }
-function escapeRegExp2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 
 // src/server.ts
 var _require2 = createRequire2(import.meta.url);
@@ -14971,14 +14860,19 @@ export {
   isFirstRun,
   showFirstRunNotice,
   trackEvent,
+  projects,
+  runs,
+  querySnapshots,
+  apiKeys,
+  createClient,
+  parseJsonColumn,
+  migrate,
   providerQuotaPolicySchema,
   resolveProviderInput,
   notificationEventSchema,
   effectiveDomains,
+  determineAnswerMentioned,
   setGoogleAuthConfig,
   formatAuditFactorScore,
-  apiKeys,
-  createClient,
-  migrate,
   createServer
 };