@ainyc/canonry 3.6.4 → 4.1.1

package/dist/{chunk-JMVBV3AT.js → chunk-BQN6BBHI.js}

@@ -4,7 +4,7 @@ import {
   configExists,
   loadConfig,
   saveConfigPatch
-} from "./chunk-RQMOJEJT.js";
+} from "./chunk-KCETXLDF.js";
 import {
   IntelligenceService,
   MIN_TREND_POINTS,
@@ -40,16 +40,16 @@ import {
   insights,
   isBlogShapedQuery,
   isTrendBaseline,
-  keywords,
   mapOpportunitiesToNextSteps,
   notifications,
   parseJsonColumn,
   projects,
+  queries,
   querySnapshots,
   runs,
   schedules,
   usageCounters
-} from "./chunk-GP2P2WPS.js";
+} from "./chunk-NCWCPBOT.js";
 import {
   AGENT_MEMORY_VALUE_MAX_BYTES,
   AGENT_PROVIDER_IDS,
@@ -99,7 +99,10 @@ import {
   projectConfigSchema,
   projectUpsertRequestSchema,
   providerError,
+  queryGenerateRequestSchema,
   registrableDomain,
+  resolveConfigSpecQueries,
+  resolveSnapshotRequestQueries,
   runInProgress,
   runNotCancellable,
   runTriggerRequestSchema,
@@ -112,7 +115,7 @@ import {
   visibilityStateFromAnswerMentioned,
   windowCutoff,
   wordpressEnvSchema
-} from "./chunk-O7EVT3AF.js";
+} from "./chunk-O5JZQUPX.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -526,7 +529,7 @@ async function projectRoutes(app, opts) {
   });
   app.get("/projects/:name/export", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const kws = app.db.select().from(keywords).where(eq3(keywords.projectId, project.id)).all();
+    const qs = app.db.select().from(queries).where(eq3(queries.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();
     const notificationRows = app.db.select().from(notifications).where(eq3(notifications.projectId, project.id)).all();
@@ -543,7 +546,7 @@ async function projectRoutes(app, opts) {
         ownedDomains: parseJsonColumn(project.ownedDomains, []),
         country: project.country,
         language: project.language,
-        keywords: kws.map((k) => k.keyword),
+        queries: qs.map((q) => q.query),
         competitors: comps.map((c) => c.domain),
         providers: parseJsonColumn(project.providers, []),
         locations: parseJsonColumn(project.locations, []),
@@ -591,14 +594,147 @@ function formatProject(row) {
   };
 }
 
-// ../api-routes/src/keywords.ts
+// ../api-routes/src/queries.ts
 import crypto5 from "crypto";
 import { eq as eq4 } from "drizzle-orm";
-async function keywordRoutes(app, opts) {
+async function queryRoutes(app, opts) {
+  app.get("/projects/:name/queries", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, query: r.query, createdAt: r.createdAt })));
+  });
+  app.put("/projects/:name/queries", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const body = request.body;
+    if (!body || !Array.isArray(body.queries)) {
+      throw validationError('Body must contain a "queries" array');
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    app.db.transaction((tx) => {
+      tx.delete(queries).where(eq4(queries.projectId, project.id)).run();
+      for (const q of body.queries) {
+        tx.insert(queries).values({
+          id: crypto5.randomUUID(),
+          projectId: project.id,
+          query: q,
+          createdAt: now
+        }).run();
+      }
+      writeAuditLog(tx, {
+        projectId: project.id,
+        actor: "api",
+        action: "queries.replaced",
+        entityType: "query",
+        diff: { queries: body.queries }
+      });
+    });
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, query: r.query, createdAt: r.createdAt })));
+  });
+  app.delete("/projects/:name/queries", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const body = request.body;
+    if (!body || !Array.isArray(body.queries) || body.queries.length === 0) {
+      throw validationError('Body must contain a non-empty "queries" array');
+    }
+    const existing = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    const toDelete = new Set(body.queries);
+    const idsToDelete = existing.filter((q) => toDelete.has(q.query)).map((q) => q.id);
+    if (idsToDelete.length > 0) {
+      app.db.transaction((tx) => {
+        for (const id of idsToDelete) {
+          tx.delete(queries).where(eq4(queries.id, id)).run();
+        }
+        writeAuditLog(tx, {
+          projectId: project.id,
+          actor: "api",
+          action: "queries.deleted",
+          entityType: "query",
+          diff: { deleted: body.queries.filter((q) => existing.some((e) => e.query === q)) }
+        });
+      });
+    }
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, query: r.query, createdAt: r.createdAt })));
+  });
+  app.post("/projects/:name/queries", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const body = request.body;
+    if (!body || !Array.isArray(body.queries)) {
+      throw validationError('Body must contain a "queries" array');
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    const existingSet = new Set(existing.map((q) => q.query));
+    const added = [];
+    for (const q of body.queries) {
+      if (!existingSet.has(q)) {
+        app.db.insert(queries).values({
+          id: crypto5.randomUUID(),
+          projectId: project.id,
+          query: q,
+          createdAt: now
+        }).run();
+        added.push(q);
+        existingSet.add(q);
+      }
+    }
+    if (added.length > 0) {
+      writeAuditLog(app.db, {
+        projectId: project.id,
+        actor: "api",
+        action: "queries.appended",
+        entityType: "query",
+        diff: { added }
+      });
+    }
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, query: r.query, createdAt: r.createdAt })));
+  });
+  app.post("/projects/:name/queries/generate", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const parsed = queryGenerateRequestSchema.safeParse(request.body);
+    if (!parsed.success) {
+      throw validationError("Invalid query generation request", {
+        issues: parsed.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      });
+    }
+    const body = parsed.data;
+    const provider = body.provider.trim().toLowerCase();
+    const validNames = opts.validProviderNames ?? [];
+    if (validNames.length && !validNames.includes(provider)) {
+      throw validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
+        provider: body.provider,
+        validProviders: validNames
+      });
+    }
+    const count = body.count ?? 5;
+    if (!opts.onGenerateQueries) {
+      throw notImplemented("Query generation is not supported in this deployment");
+    }
+    const existingRows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    const existingQueries = existingRows.map((r) => r.query);
+    try {
+      const generated = await opts.onGenerateQueries(provider, count, {
+        domain: project.canonicalDomain,
+        displayName: project.displayName,
+        country: project.country,
+        language: project.language,
+        existingQueries
+      });
+      return reply.send({ queries: generated, provider });
+    } catch (err) {
+      request.log.error({ err }, "Query generation failed");
+      throw internalError(err instanceof Error ? err.message : "Failed to generate queries");
+    }
+  });
   app.get("/projects/:name/keywords", async (request, reply) => {
     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 })));
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, keyword: r.query, createdAt: r.createdAt })));
   });
   app.put("/projects/:name/keywords", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -608,25 +744,25 @@ async function keywordRoutes(app, opts) {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
-      tx.delete(keywords).where(eq4(keywords.projectId, project.id)).run();
-      for (const kw of body.keywords) {
-        tx.insert(keywords).values({
+      tx.delete(queries).where(eq4(queries.projectId, project.id)).run();
+      for (const keyword of body.keywords) {
+        tx.insert(queries).values({
           id: crypto5.randomUUID(),
           projectId: project.id,
-          keyword: kw,
+          query: keyword,
           createdAt: now
         }).run();
       }
       writeAuditLog(tx, {
         projectId: project.id,
         actor: "api",
-        action: "keywords.replaced",
-        entityType: "keyword",
-        diff: { keywords: body.keywords }
+        action: "queries.replaced",
+        entityType: "query",
+        diff: { queries: body.keywords }
       });
     });
-    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 })));
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, keyword: r.query, createdAt: r.createdAt })));
   });
   app.delete("/projects/:name/keywords", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -634,25 +770,25 @@ async function keywordRoutes(app, opts) {
     if (!body || !Array.isArray(body.keywords) || body.keywords.length === 0) {
       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 existing = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
     const toDelete = new Set(body.keywords);
-    const idsToDelete = existing.filter((k) => toDelete.has(k.keyword)).map((k) => k.id);
+    const idsToDelete = existing.filter((q) => toDelete.has(q.query)).map((q) => q.id);
     if (idsToDelete.length > 0) {
       app.db.transaction((tx) => {
         for (const id of idsToDelete) {
-          tx.delete(keywords).where(eq4(keywords.id, id)).run();
+          tx.delete(queries).where(eq4(queries.id, id)).run();
         }
         writeAuditLog(tx, {
           projectId: project.id,
           actor: "api",
-          action: "keywords.deleted",
-          entityType: "keyword",
-          diff: { deleted: body.keywords.filter((kw) => existing.some((e) => e.keyword === kw)) }
+          action: "queries.deleted",
+          entityType: "query",
+          diff: { deleted: body.keywords.filter((keyword) => existing.some((e) => e.query === keyword)) }
         });
       });
     }
-    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 })));
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, keyword: r.query, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -661,32 +797,32 @@ async function keywordRoutes(app, opts) {
       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();
-    const existingSet = new Set(existing.map((k) => k.keyword));
+    const existing = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    const existingSet = new Set(existing.map((q) => q.query));
     const added = [];
-    for (const kw of body.keywords) {
-      if (!existingSet.has(kw)) {
-        app.db.insert(keywords).values({
+    for (const keyword of body.keywords) {
+      if (!existingSet.has(keyword)) {
+        app.db.insert(queries).values({
           id: crypto5.randomUUID(),
           projectId: project.id,
-          keyword: kw,
+          query: keyword,
           createdAt: now
         }).run();
-        added.push(kw);
-        existingSet.add(kw);
+        added.push(keyword);
+        existingSet.add(keyword);
       }
     }
     if (added.length > 0) {
       writeAuditLog(app.db, {
         projectId: project.id,
         actor: "api",
-        action: "keywords.appended",
-        entityType: "keyword",
+        action: "queries.appended",
+        entityType: "query",
         diff: { added }
       });
     }
-    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 })));
+    const rows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, keyword: r.query, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords/generate", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -709,23 +845,23 @@ async function keywordRoutes(app, opts) {
       });
     }
     const count = body.count ?? 5;
-    if (!opts.onGenerateKeywords) {
-      throw notImplemented("Key phrase generation is not supported in this deployment");
+    if (!opts.onGenerateQueries) {
+      throw notImplemented("Keyword 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);
+    const existingRows = app.db.select().from(queries).where(eq4(queries.projectId, project.id)).all();
+    const existingQueries = existingRows.map((r) => r.query);
     try {
-      const generated = await opts.onGenerateKeywords(provider, count, {
+      const generated = await opts.onGenerateQueries(provider, count, {
         domain: project.canonicalDomain,
         displayName: project.displayName,
         country: project.country,
         language: project.language,
-        existingKeywords
+        existingQueries
       });
       return reply.send({ keywords: generated, provider });
     } catch (err) {
-      request.log.error({ err }, "Key phrase generation failed");
-      throw internalError(err instanceof Error ? err.message : "Failed to generate key phrases");
+      request.log.error({ err }, "Keyword generation failed");
+      throw internalError(err instanceof Error ? err.message : "Failed to generate keywords");
     }
   });
 }
@@ -1138,8 +1274,8 @@ function loadRunDetail(app, run) {
   const snapshots = app.db.select({
     id: querySnapshots.id,
     runId: querySnapshots.runId,
-    keywordId: querySnapshots.keywordId,
-    keyword: keywords.keyword,
+    queryId: querySnapshots.queryId,
+    query: queries.query,
     provider: querySnapshots.provider,
     model: querySnapshots.model,
     citationState: querySnapshots.citationState,
@@ -1151,7 +1287,7 @@ function loadRunDetail(app, run) {
     location: querySnapshots.location,
     rawResponse: querySnapshots.rawResponse,
     createdAt: querySnapshots.createdAt
-  }).from(querySnapshots).leftJoin(keywords, eq7(querySnapshots.keywordId, keywords.id)).where(eq7(querySnapshots.runId, run.id)).all();
+  }).from(querySnapshots).leftJoin(queries, eq7(querySnapshots.queryId, queries.id)).where(eq7(querySnapshots.runId, run.id)).all();
   return {
     ...formatRun(run),
     snapshots: snapshots.map((s) => {
@@ -1160,8 +1296,8 @@ function loadRunDetail(app, run) {
       return {
         id: s.id,
         runId: s.runId,
-        keywordId: s.keywordId,
-        keyword: s.keyword,
+        queryId: s.queryId,
+        query: s.query,
         provider: s.provider,
         citationState: s.citationState,
         answerMentioned,
@@ -1497,6 +1633,7 @@ async function applyRoutes(app, opts) {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const name = config.metadata.name;
+    const configQueries = resolveConfigSpecQueries(config.spec);
     let projectId;
     let scheduleAction = null;
     app.db.transaction((tx) => {
@@ -1554,21 +1691,21 @@ async function applyRoutes(app, opts) {
           entityId: projectId
         });
       }
-      tx.delete(keywords).where(eq8(keywords.projectId, projectId)).run();
-      for (const kw of config.spec.keywords) {
-        tx.insert(keywords).values({
+      tx.delete(queries).where(eq8(queries.projectId, projectId)).run();
+      for (const q of configQueries) {
+        tx.insert(queries).values({
           id: crypto10.randomUUID(),
           projectId,
-          keyword: kw,
+          query: q,
           createdAt: now
         }).run();
       }
       writeAuditLog(tx, {
         projectId,
         actor: "api",
-        action: "keywords.replaced",
-        entityType: "keyword",
-        diff: { keywords: config.spec.keywords }
+        action: "queries.replaced",
+        entityType: "query",
+        diff: { queries: configQueries }
       });
       tx.delete(competitors).where(eq8(competitors.projectId, projectId)).run();
       const normalizedCompetitors = normalizeCompetitorList2(config.spec.competitors);
@@ -1752,8 +1889,8 @@ async function historyRoutes(app) {
     const allSnapshots = app.db.select({
       id: querySnapshots.id,
       runId: querySnapshots.runId,
-      keywordId: querySnapshots.keywordId,
-      keyword: keywords.keyword,
+      queryId: querySnapshots.queryId,
+      query: queries.query,
       provider: querySnapshots.provider,
       model: querySnapshots.model,
       citationState: querySnapshots.citationState,
@@ -1764,7 +1901,7 @@ async function historyRoutes(app) {
       recommendedCompetitors: querySnapshots.recommendedCompetitors,
       location: querySnapshots.location,
       createdAt: querySnapshots.createdAt
-    }).from(querySnapshots).leftJoin(keywords, eq9(querySnapshots.keywordId, keywords.id)).where(inArray(querySnapshots.runId, projectRuns.map((r) => r.id))).orderBy(desc2(querySnapshots.createdAt)).all();
+    }).from(querySnapshots).leftJoin(queries, eq9(querySnapshots.queryId, queries.id)).where(inArray(querySnapshots.runId, projectRuns.map((r) => r.id))).orderBy(desc2(querySnapshots.createdAt)).all();
     const locationFilter = request.query.location;
     const filtered = locationFilter !== void 0 ? allSnapshots.filter((s) => s.location === (locationFilter || null)) : allSnapshots;
     const total = filtered.length;
@@ -1773,8 +1910,8 @@ async function historyRoutes(app) {
       snapshots: paged.map((s) => ({
         id: s.id,
         runId: s.runId,
-        keywordId: s.keywordId,
-        keyword: s.keyword,
+        queryId: s.queryId,
+        query: s.query,
         provider: s.provider,
         model: s.model,
         citationState: s.citationState,
@@ -1792,9 +1929,9 @@ async function historyRoutes(app) {
   });
   app.get("/projects/:name/timeline", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const projectKeywords = app.db.select().from(keywords).where(eq9(keywords.projectId, project.id)).all();
+    const projectQueries = app.db.select().from(queries).where(eq9(queries.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) {
+    if (projectRuns.length === 0 || projectQueries.length === 0) {
       return reply.send([]);
     }
     const runIds = new Set(projectRuns.map((r) => r.id));
@@ -1807,26 +1944,26 @@ async function historyRoutes(app) {
     }));
     const deduped = /* @__PURE__ */ new Map();
     for (const snap of allSnapshots) {
-      const key = `${snap.runId}:${snap.keywordId}`;
+      const key = `${snap.runId}:${snap.queryId}`;
       const existing = deduped.get(key);
       if (!existing || !existing.answerMentioned && snap.answerMentioned || existing.answerMentioned === snap.answerMentioned && snap.citationState === "cited") {
         deduped.set(key, snap);
       }
     }
     const dedupedSnapshots = [...deduped.values()];
-    const rawByKwProvider = /* @__PURE__ */ new Map();
+    const rawByQueryProvider = /* @__PURE__ */ new Map();
     for (const snap of allSnapshots) {
-      const key = `${snap.keywordId}::${snap.provider}`;
-      const arr = rawByKwProvider.get(key);
+      const key = `${snap.queryId}::${snap.provider}`;
+      const arr = rawByQueryProvider.get(key);
       if (arr) arr.push(snap);
-      else rawByKwProvider.set(key, [snap]);
+      else rawByQueryProvider.set(key, [snap]);
     }
-    const rawByKwModel = /* @__PURE__ */ new Map();
+    const rawByQueryModel = /* @__PURE__ */ new Map();
     for (const snap of allSnapshots) {
-      const key = `${snap.keywordId}::${snap.provider}:${snap.model ?? "unknown"}`;
-      const arr = rawByKwModel.get(key);
+      const key = `${snap.queryId}::${snap.provider}:${snap.model ?? "unknown"}`;
+      const arr = rawByQueryModel.get(key);
       if (arr) arr.push(snap);
-      else rawByKwModel.set(key, [snap]);
+      else rawByQueryModel.set(key, [snap]);
     }
     function computeTransitions(snaps) {
       return snaps.map((snap, idx) => {
@@ -1860,25 +1997,25 @@ async function historyRoutes(app) {
         };
       });
     }
-    const timeline = projectKeywords.map((kw) => {
-      const kwSnapshots = dedupedSnapshots.filter((s) => s.keywordId === kw.id).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-      const runEntries = computeTransitions(kwSnapshots);
+    const timeline = projectQueries.map((q) => {
+      const qSnapshots = dedupedSnapshots.filter((s) => s.queryId === q.id).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+      const runEntries = computeTransitions(qSnapshots);
       const providerRuns = {};
-      const providerKeys = [...rawByKwProvider.keys()].filter((k) => k.startsWith(`${kw.id}::`));
+      const providerKeys = [...rawByQueryProvider.keys()].filter((k) => k.startsWith(`${q.id}::`));
       for (const pk of providerKeys) {
         const provider = pk.split("::")[1];
-        const provSnaps = rawByKwProvider.get(pk).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        const provSnaps = rawByQueryProvider.get(pk).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
         providerRuns[provider] = computeTransitions(provSnaps);
       }
       const modelRuns = {};
-      const modelKeys = [...rawByKwModel.keys()].filter((k) => k.startsWith(`${kw.id}::`));
+      const modelKeys = [...rawByQueryModel.keys()].filter((k) => k.startsWith(`${q.id}::`));
       for (const mk of modelKeys) {
         const modelKey = mk.split("::")[1];
-        const modelSnaps = rawByKwModel.get(mk).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        const modelSnaps = rawByQueryModel.get(mk).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
         modelRuns[modelKey] = computeTransitions(modelSnaps);
       }
       return {
-        keyword: kw.keyword,
+        query: q.query,
         runs: runEntries,
         providerRuns,
         modelRuns
@@ -1893,19 +2030,19 @@ async function historyRoutes(app) {
       throw validationError("Both run1 and run2 query params are required");
     }
     const snaps1 = app.db.select({
-      keywordId: querySnapshots.keywordId,
-      keyword: keywords.keyword,
+      queryId: querySnapshots.queryId,
+      query: queries.query,
       citationState: querySnapshots.citationState,
       answerMentioned: querySnapshots.answerMentioned,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).leftJoin(keywords, eq9(querySnapshots.keywordId, keywords.id)).where(eq9(querySnapshots.runId, run1)).all();
+    }).from(querySnapshots).leftJoin(queries, eq9(querySnapshots.queryId, queries.id)).where(eq9(querySnapshots.runId, run1)).all();
     const snaps2 = app.db.select({
-      keywordId: querySnapshots.keywordId,
-      keyword: keywords.keyword,
+      queryId: querySnapshots.queryId,
+      query: queries.query,
       citationState: querySnapshots.citationState,
       answerMentioned: querySnapshots.answerMentioned,
       answerText: querySnapshots.answerText
-    }).from(querySnapshots).leftJoin(keywords, eq9(querySnapshots.keywordId, keywords.id)).where(eq9(querySnapshots.runId, run2)).all();
+    }).from(querySnapshots).leftJoin(queries, eq9(querySnapshots.queryId, queries.id)).where(eq9(querySnapshots.runId, run2)).all();
     const map1 = /* @__PURE__ */ new Map();
     for (const s of snaps1) {
       const resolved = {
@@ -1913,9 +2050,9 @@ async function historyRoutes(app) {
         resolvedAnswerMentioned: resolveSnapshotAnswerMentioned(s, project),
         resolvedVisibilityState: resolveSnapshotVisibilityState(s, project)
       };
-      const existing = map1.get(s.keywordId);
+      const existing = map1.get(s.queryId);
       if (!existing || !existing.resolvedAnswerMentioned && resolved.resolvedAnswerMentioned || existing.resolvedAnswerMentioned === resolved.resolvedAnswerMentioned && resolved.citationState === "cited") {
-        map1.set(s.keywordId, resolved);
+        map1.set(s.queryId, resolved);
       }
     }
     const map2 = /* @__PURE__ */ new Map();
@@ -1925,18 +2062,18 @@ async function historyRoutes(app) {
         resolvedAnswerMentioned: resolveSnapshotAnswerMentioned(s, project),
         resolvedVisibilityState: resolveSnapshotVisibilityState(s, project)
       };
-      const existing = map2.get(s.keywordId);
+      const existing = map2.get(s.queryId);
       if (!existing || !existing.resolvedAnswerMentioned && resolved.resolvedAnswerMentioned || existing.resolvedAnswerMentioned === resolved.resolvedAnswerMentioned && resolved.citationState === "cited") {
-        map2.set(s.keywordId, resolved);
+        map2.set(s.queryId, resolved);
       }
     }
-    const allKeywordIds = /* @__PURE__ */ new Set([...map1.keys(), ...map2.keys()]);
-    const diff = [...allKeywordIds].map((kwId) => {
-      const s1 = map1.get(kwId);
-      const s2 = map2.get(kwId);
+    const allQueryIds = /* @__PURE__ */ new Set([...map1.keys(), ...map2.keys()]);
+    const diff = [...allQueryIds].map((qId) => {
+      const s1 = map1.get(qId);
+      const s2 = map2.get(qId);
       return {
-        keywordId: kwId,
-        keyword: s2?.keyword ?? s1?.keyword ?? null,
+        queryId: qId,
+        query: s2?.query ?? s1?.query ?? null,
         run1State: s1?.citationState ?? null,
         run2State: s2?.citationState ?? null,
         run1AnswerMentioned: s1?.resolvedAnswerMentioned ?? null,
@@ -1979,13 +2116,13 @@ async function analyticsRoutes(app) {
         byProvider: {},
         trend: "stable",
         mentionTrend: "stable",
-        keywordChanges: []
+        queryChanges: []
       });
     }
     const runIds = projectRuns.map((r) => r.id);
     const rawSnapshots = app.db.select({
       runId: querySnapshots.runId,
-      keywordId: querySnapshots.keywordId,
+      queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState,
       answerMentioned: querySnapshots.answerMentioned,
@@ -1996,8 +2133,8 @@ async function analyticsRoutes(app) {
       ...s,
       resolvedMentioned: resolveSnapshotAnswerMentioned(s, project)
     }));
-    const projectKeywords = app.db.select({ id: keywords.id, createdAt: keywords.createdAt }).from(keywords).where(eq10(keywords.projectId, project.id)).all();
-    const keywordCreatedAt = new Map(projectKeywords.map((k) => [k.id, k.createdAt]));
+    const projectQueries = app.db.select({ id: queries.id, createdAt: queries.createdAt }).from(queries).where(eq10(queries.projectId, project.id)).all();
+    const queryCreatedAt = new Map(projectQueries.map((q) => [q.id, q.createdAt]));
     const overall = computeProviderMetric(allSnapshots);
     const byProvider = {};
     const providers = new Set(allSnapshots.map((s) => s.provider));
@@ -2008,11 +2145,11 @@ async function analyticsRoutes(app) {
     const latest = new Date(projectRuns[projectRuns.length - 1].createdAt);
     const spanDays = Math.max(1, Math.ceil((latest.getTime() - earliest.getTime()) / 864e5));
     const bucketSize = bucketSizeForSpan(spanDays);
-    const buckets = computeBuckets(allSnapshots, projectRuns, bucketSize, keywordCreatedAt);
+    const buckets = computeBuckets(allSnapshots, projectRuns, bucketSize, queryCreatedAt);
     const trend = computeTrend(buckets, "citationRate");
     const mentionTrend = computeTrend(buckets, "mentionRate");
-    const keywordChanges = computeKeywordChanges(projectKeywords, cutoff);
-    return reply.send({ window, buckets, overall, byProvider, trend, mentionTrend, keywordChanges });
+    const queryChanges = computeQueryChanges(projectQueries, cutoff);
+    return reply.send({ window, buckets, overall, byProvider, trend, mentionTrend, queryChanges });
   });
   app.get("/projects/:name/analytics/gaps", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -2020,24 +2157,24 @@ async function analyticsRoutes(app) {
     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");
     if (!latestRun) {
-      return reply.send({ cited: [], gap: [], uncited: [], mentionedKeywords: [], mentionGap: [], notMentioned: [], runId: "", window });
+      return reply.send({ cited: [], gap: [], uncited: [], mentionedQueries: [], mentionGap: [], notMentioned: [], runId: "", window });
     }
     const windowRuns = 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);
     const windowRunIds = windowRuns.map((r) => r.id);
     const consistencyMap = /* @__PURE__ */ new Map();
     if (windowRunIds.length > 0) {
       const allWindowSnaps = app.db.select({
-        keywordId: querySnapshots.keywordId,
+        queryId: querySnapshots.queryId,
         runId: querySnapshots.runId,
         citationState: querySnapshots.citationState,
         answerMentioned: querySnapshots.answerMentioned,
         answerText: querySnapshots.answerText
       }).from(querySnapshots).where(inArray2(querySnapshots.runId, windowRunIds)).all();
       for (const s of allWindowSnaps) {
-        let entry = consistencyMap.get(s.keywordId);
+        let entry = consistencyMap.get(s.queryId);
         if (!entry) {
           entry = { citedRuns: /* @__PURE__ */ new Set(), totalRuns: /* @__PURE__ */ new Set(), mentionedRuns: /* @__PURE__ */ new Set() };
-          consistencyMap.set(s.keywordId, entry);
+          consistencyMap.set(s.queryId, entry);
         }
         entry.totalRuns.add(s.runId);
         if (s.citationState === "cited") entry.citedRuns.add(s.runId);
@@ -2045,41 +2182,41 @@ async function analyticsRoutes(app) {
       }
     }
     const rawSnapshots = app.db.select({
-      keywordId: querySnapshots.keywordId,
-      keyword: keywords.keyword,
+      queryId: querySnapshots.queryId,
+      query: queries.query,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState,
       answerMentioned: querySnapshots.answerMentioned,
       answerText: querySnapshots.answerText,
       competitorOverlap: querySnapshots.competitorOverlap
-    }).from(querySnapshots).leftJoin(keywords, eq10(querySnapshots.keywordId, keywords.id)).where(eq10(querySnapshots.runId, latestRun.id)).all();
+    }).from(querySnapshots).leftJoin(queries, eq10(querySnapshots.queryId, queries.id)).where(eq10(querySnapshots.runId, latestRun.id)).all();
     const snapshots = rawSnapshots.map((s) => ({
       ...s,
       resolvedMentioned: resolveSnapshotAnswerMentioned(s, project)
     }));
-    const byKeyword = /* @__PURE__ */ new Map();
+    const byQuery = /* @__PURE__ */ new Map();
     for (const s of snapshots) {
-      const key = s.keywordId;
-      const arr = byKeyword.get(key);
+      const key = s.queryId;
+      const arr = byQuery.get(key);
       if (arr) arr.push(s);
-      else byKeyword.set(key, [s]);
+      else byQuery.set(key, [s]);
     }
     const cited = [];
     const gap = [];
     const uncited = [];
-    const mentionedKeywords = [];
+    const mentionedQueries = [];
     const mentionGap = [];
     const notMentioned = [];
-    for (const [keywordId, kwSnapshots] of byKeyword) {
-      const keyword = kwSnapshots[0]?.keyword ?? "";
-      const citedProviders = kwSnapshots.filter((s) => s.citationState === "cited").map((s) => s.provider);
-      const mentionedProviders = kwSnapshots.filter((s) => s.resolvedMentioned).map((s) => s.provider);
+    for (const [queryId, qSnapshots] of byQuery) {
+      const query = qSnapshots[0]?.query ?? "";
+      const citedProviders = qSnapshots.filter((s) => s.citationState === "cited").map((s) => s.provider);
+      const mentionedProviders = qSnapshots.filter((s) => s.resolvedMentioned).map((s) => s.provider);
       const competitorsCiting = /* @__PURE__ */ new Set();
-      for (const s of kwSnapshots) {
+      for (const s of qSnapshots) {
         const overlap = parseJsonColumn(s.competitorOverlap, []);
         for (const c of overlap) competitorsCiting.add(c);
       }
-      const cons = consistencyMap.get(keywordId);
+      const cons = consistencyMap.get(queryId);
       const consistency = {
         citedRuns: cons?.citedRuns.size ?? 0,
         totalRuns: cons?.totalRuns.size ?? 0,
@@ -2094,8 +2231,8 @@ async function analyticsRoutes(app) {
         category = "uncited";
       }
       const citationEntry = {
-        keyword,
-        keywordId,
+        query,
+        queryId,
         category,
         providers: citedProviders,
         competitorsCiting: [...competitorsCiting],
@@ -2113,24 +2250,24 @@ async function analyticsRoutes(app) {
         mentionCategory = "uncited";
       }
       const mentionEntry = {
-        keyword,
-        keywordId,
+        query,
+        queryId,
         category: mentionCategory,
         providers: mentionedProviders,
         competitorsCiting: [...competitorsCiting],
         consistency
       };
-      if (mentionCategory === "cited") mentionedKeywords.push(mentionEntry);
+      if (mentionCategory === "cited") mentionedQueries.push(mentionEntry);
       else if (mentionCategory === "gap") mentionGap.push(mentionEntry);
       else notMentioned.push(mentionEntry);
     }
     gap.sort((a, b) => b.competitorsCiting.length - a.competitorsCiting.length);
-    cited.sort((a, b) => a.keyword.localeCompare(b.keyword));
-    uncited.sort((a, b) => a.keyword.localeCompare(b.keyword));
+    cited.sort((a, b) => a.query.localeCompare(b.query));
+    uncited.sort((a, b) => a.query.localeCompare(b.query));
     mentionGap.sort((a, b) => b.competitorsCiting.length - a.competitorsCiting.length);
-    mentionedKeywords.sort((a, b) => a.keyword.localeCompare(b.keyword));
-    notMentioned.sort((a, b) => a.keyword.localeCompare(b.keyword));
-    return reply.send({ cited, gap, uncited, mentionedKeywords, mentionGap, notMentioned, runId: latestRun.id, window });
+    mentionedQueries.sort((a, b) => a.query.localeCompare(b.query));
+    notMentioned.sort((a, b) => a.query.localeCompare(b.query));
+    return reply.send({ cited, gap, uncited, mentionedQueries, mentionGap, notMentioned, runId: latestRun.id, window });
   });
   app.get("/projects/:name/analytics/sources", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
@@ -2138,35 +2275,35 @@ async function analyticsRoutes(app) {
     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);
     if (windowRuns.length === 0) {
-      return reply.send({ overall: [], byKeyword: {}, runId: "", window });
+      return reply.send({ overall: [], byQuery: {}, runId: "", window });
     }
     const latestRunId = windowRuns[0].id;
     const windowRunIds = windowRuns.map((r) => r.id);
     const snapshots = app.db.select({
-      keywordId: querySnapshots.keywordId,
-      keyword: keywords.keyword,
+      queryId: querySnapshots.queryId,
+      query: queries.query,
       rawResponse: querySnapshots.rawResponse
-    }).from(querySnapshots).leftJoin(keywords, eq10(querySnapshots.keywordId, keywords.id)).where(inArray2(querySnapshots.runId, windowRunIds)).all();
+    }).from(querySnapshots).leftJoin(queries, eq10(querySnapshots.queryId, queries.id)).where(inArray2(querySnapshots.runId, windowRunIds)).all();
     const overallCounts = /* @__PURE__ */ new Map();
-    const byKeyword = {};
+    const byQuery = {};
     for (const snap of snapshots) {
       const sources = parseGroundingSources(snap.rawResponse);
-      const kwCounts = /* @__PURE__ */ new Map();
+      const qCounts = /* @__PURE__ */ new Map();
       for (const source of sources) {
         const { category, domain } = categorizeSource(source.uri);
         if (!overallCounts.has(category)) overallCounts.set(category, /* @__PURE__ */ new Map());
         const oDomains = overallCounts.get(category);
         oDomains.set(domain, (oDomains.get(domain) ?? 0) + 1);
-        if (!kwCounts.has(category)) kwCounts.set(category, /* @__PURE__ */ new Map());
-        const kDomains = kwCounts.get(category);
-        kDomains.set(domain, (kDomains.get(domain) ?? 0) + 1);
+        if (!qCounts.has(category)) qCounts.set(category, /* @__PURE__ */ new Map());
+        const qDomains = qCounts.get(category);
+        qDomains.set(domain, (qDomains.get(domain) ?? 0) + 1);
       }
-      if (sources.length > 0 && snap.keyword) {
-        byKeyword[snap.keyword] = buildCategoryCounts(kwCounts);
+      if (sources.length > 0 && snap.query) {
+        byQuery[snap.query] = buildCategoryCounts(qCounts);
       }
     }
     const overall = buildCategoryCounts(overallCounts);
-    return reply.send({ overall, byKeyword, runId: latestRunId, window });
+    return reply.send({ overall, byQuery, runId: latestRunId, window });
   });
 }
 var PROVIDER_INFRA_DOMAINS = /* @__PURE__ */ new Set([
@@ -2211,7 +2348,7 @@ function computeProviderMetric(snapshots) {
     mentionedCount
   };
 }
-function computeBuckets(snapshots, projectRuns, bucketDays, keywordCreatedAt) {
+function computeBuckets(snapshots, projectRuns, bucketDays, queryCreatedAt) {
   if (projectRuns.length === 0) return [];
   const earliest = new Date(projectRuns[0].createdAt);
   const latest = new Date(projectRuns[projectRuns.length - 1].createdAt);
@@ -2226,22 +2363,22 @@ function computeBuckets(snapshots, projectRuns, bucketDays, keywordCreatedAt) {
     const inBucket = snapshots.filter((s) => s.createdAt >= startISO && s.createdAt < endISO);
     if (inBucket.length > 0) {
       let usable = inBucket;
-      if (keywordCreatedAt) {
+      if (queryCreatedAt) {
         const eligible = inBucket.filter((s) => {
-          const kwCreated = keywordCreatedAt.get(s.keywordId);
-          return kwCreated !== void 0 && kwCreated < startISO;
+          const qCreated = queryCreatedAt.get(s.queryId);
+          return qCreated !== void 0 && qCreated < startISO;
         });
         if (eligible.length > 0) usable = eligible;
       }
       const metric = computeProviderMetric(usable);
-      const keywordCount = new Set(usable.map((s) => s.keywordId)).size;
+      const queryCount = new Set(usable.map((s) => s.queryId)).size;
       buckets.push({
         startDate: startISO,
         endDate: endISO,
         citationRate: metric.citationRate,
         cited: metric.cited,
         total: metric.total,
-        keywordCount,
+        queryCount,
         mentionRate: metric.mentionRate,
         mentionedCount: metric.mentionedCount
       });
@@ -2250,11 +2387,11 @@ function computeBuckets(snapshots, projectRuns, bucketDays, keywordCreatedAt) {
   }
   return buckets;
 }
-function computeKeywordChanges(projectKeywords, cutoff) {
+function computeQueryChanges(projectQueries, cutoff) {
   const byDay = /* @__PURE__ */ new Map();
-  for (const kw of projectKeywords) {
-    if (cutoff && kw.createdAt < cutoff) continue;
-    const day = kw.createdAt.slice(0, 10);
+  for (const q of projectQueries) {
+    if (cutoff && q.createdAt < cutoff) continue;
+    const day = q.createdAt.slice(0, 10);
     byDay.set(day, (byDay.get(day) ?? 0) + 1);
   }
   const days = [...byDay.entries()].sort((a, b) => a[0].localeCompare(b[0]));
@@ -2328,7 +2465,7 @@ function mapInsightRow(r) {
     type: r.type,
     severity: r.severity,
     title: r.title,
-    keyword: r.keyword,
+    query: r.query,
     provider: r.provider,
     recommendation: parseJsonColumn(r.recommendation, void 0),
     cause: parseJsonColumn(r.cause, void 0),
@@ -2752,8 +2889,8 @@ function renderExecutiveSummary(report) {
       delta: `<span class="tone-${trendTone}">${trendLabel}</span> \xB7 ${s.providerCount} provider${s.providerCount === 1 ? "" : "s"}`
     },
     {
-      label: "Keywords tracked",
-      value: formatNumber(s.keywordCount),
+      label: "Queries tracked",
+      value: formatNumber(s.queryCount),
       delta: `${s.competitorCount} competitor${s.competitorCount === 1 ? "" : "s"} tracked`
     }
   ];
@@ -2820,13 +2957,13 @@ function renderProviderBars(rates) {
   </div>`;
 }
 function renderCitationMatrix(scorecard) {
-  if (scorecard.keywords.length === 0 || scorecard.providers.length === 0) {
+  if (scorecard.queries.length === 0 || scorecard.providers.length === 0) {
     return renderEmpty("Run a visibility sweep to populate the citation matrix.");
   }
   const headers = scorecard.providers.map((p) => `<th>${escapeHtml(p)}</th>`).join("");
-  const rows = scorecard.keywords.map((kw, ki) => {
+  const rows = scorecard.queries.map((q, qi) => {
     const cells = scorecard.providers.map((_, pi) => {
-      const cell = scorecard.matrix[ki]?.[pi];
+      const cell = scorecard.matrix[qi]?.[pi];
       if (!cell) {
         return '<td><span class="cell-pending">\u2014</span></td>';
       }
@@ -2835,10 +2972,10 @@ function renderCitationMatrix(scorecard) {
       }
       return '<td><span class="cell-not-cited">Not cited</span></td>';
     }).join("");
-    return `<tr><td>${escapeHtml(kw)}</td>${cells}</tr>`;
+    return `<tr><td>${escapeHtml(q)}</td>${cells}</tr>`;
   }).join("");
   return `<table class="report-table">
-    <thead><tr><th>Keyword</th>${headers}</tr></thead>
+    <thead><tr><th>Query</th>${headers}</tr></thead>
     <tbody>${rows}</tbody>
   </table>`;
 }
@@ -2848,7 +2985,7 @@ function renderCitationScorecard(report) {
     ${renderCitationMatrix(report.citationScorecard)}
   `;
   return section(
-    { id: "citation-scorecard", eyebrow: "Section 2", title: "Citation Scorecard", intro: "Whether your domain appeared in each AI engine\u2019s source list for every tracked keyword in the latest sweep \u2014 a cell turns green when your domain was cited, red when it was not, and gray when no snapshot exists for that pair." },
+    { id: "citation-scorecard", eyebrow: "Section 2", title: "Citation Scorecard", intro: "Whether your domain appeared in each AI engine\u2019s source list for every tracked query in the latest sweep \u2014 a cell turns green when your domain was cited, red when it was not, and gray when no snapshot exists for that pair." },
     body
   );
 }
@@ -2915,11 +3052,11 @@ function renderCompetitorLandscape(report) {
       <td class="numeric">${c.citationCount} / ${c.totalCount}</td>
       <td class="numeric">${mentionCount} / ${mentionTotal}</td>
       <td class="numeric">${c.sharePct}%</td>
-      <td>${escapeHtml(c.citedKeywords.slice(0, 5).join(", "))}${c.citedKeywords.length > 5 ? "\u2026" : ""}${pagesDisclosure}</td>
+      <td>${escapeHtml(c.citedQueries.slice(0, 5).join(", "))}${c.citedQueries.length > 5 ? "\u2026" : ""}${pagesDisclosure}</td>
     </tr>`;
   }).join("");
   const table = competitors2.length > 0 ? `<table class="report-table">
-        <thead><tr><th>Domain</th><th>Pressure</th><th>Citations</th><th class="numeric">Mentions</th><th class="numeric">SOV</th><th>Cited keywords</th></tr></thead>
+        <thead><tr><th>Domain</th><th>Pressure</th><th>Citations</th><th class="numeric">Mentions</th><th class="numeric">SOV</th><th>Cited queries</th></tr></thead>
         <tbody>${rows}</tbody>
       </table>` : renderEmpty("No competitors configured.");
   const citationBars = renderCompetitorBars(report.competitorLandscape, report.meta.project.canonicalDomain);
@@ -3066,14 +3203,14 @@ function renderGsc(report) {
   );
   const crossoverBlocks = [];
   if (gsc.trackedButNoGsc.length > 0) {
-    crossoverBlocks.push(`<div class="chart-card"><h3>AEO keywords without search demand</h3>
-      <p class="section-intro">Tracked AEO keywords with no GSC impressions in this window \u2014 review whether they represent real search demand.</p>
-      <ul>${gsc.trackedButNoGsc.map((k) => `<li>${escapeHtml(k)}</li>`).join("")}</ul>
+    crossoverBlocks.push(`<div class="chart-card"><h3>AEO queries without search demand</h3>
+      <p class="section-intro">Tracked AEO queries with no GSC impressions in this window \u2014 review whether they represent real search demand.</p>
+      <ul>${gsc.trackedButNoGsc.map((q) => `<li>${escapeHtml(q)}</li>`).join("")}</ul>
     </div>`);
   }
   if (gsc.gscButNotTracked.length > 0) {
     crossoverBlocks.push(`<div class="chart-card"><h3>Search queries you should track</h3>
-      <p class="section-intro">GSC top queries (by impressions) that aren't tracked in your AEO project \u2014 candidates to add as keywords.</p>
+      <p class="section-intro">GSC top queries (by impressions) that aren't tracked in your AEO project \u2014 candidates to add as queries.</p>
       <ul>${gsc.gscButNotTracked.map((q) => `<li>${escapeHtml(q)}</li>`).join("")}</ul>
     </div>`);
   }
@@ -3322,7 +3459,7 @@ function renderInsights(report) {
     return `<tr>
         <td><span class="badge tone-${tone}">${escapeHtml(i.severity)}</span></td>
         <td>${escapeHtml(i.title)}${countChip}</td>
-        <td>${escapeHtml(i.keyword)}</td>
+        <td>${escapeHtml(i.query)}</td>
         <td>${escapeHtml(i.provider)}</td>
         <td>${i.recommendation ? escapeHtml(i.recommendation) : '<span class="cell-pending">\u2014</span>'}</td>
       </tr>`;
@@ -3330,7 +3467,7 @@ function renderInsights(report) {
   return section(
     { id: "insights", eyebrow: "Section 11", title: "Insights & Alerts", intro: "Regressions (citations lost), gains (citations won), and opportunities surfaced by the intelligence engine across the most recent sweeps \u2014 ordered by severity and recurrence." },
     `<table class="report-table">
-      <thead><tr><th>Severity</th><th>Title</th><th>Keyword</th><th>Provider</th><th>Recommendation</th></tr></thead>
+      <thead><tr><th>Severity</th><th>Title</th><th>Query</th><th>Provider</th><th>Recommendation</th></tr></thead>
       <tbody>${rows}</tbody>
     </table>`
   );
@@ -3436,8 +3573,8 @@ function loadOrchestratorInput(db, project) {
   const ownDomain = normalizeDomain(project.canonicalDomain);
   const ownedDomains = parseJsonColumn(project.ownedDomains, []);
   const ourDomains = /* @__PURE__ */ new Set([ownDomain, ...ownedDomains.map(normalizeDomain)]);
-  const trackedKeywords = listKeywords(db, projectId);
-  const candidateQueryStrings = trackedKeywords.filter(isBlogShapedQuery);
+  const trackedQueries = listQueries(db, projectId);
+  const candidateQueryStrings = trackedQueries.filter(isBlogShapedQuery);
   const trackedCompetitors = listCompetitorDomains(db, projectId).map(normalizeDomain);
   const competitorSet = new Set(trackedCompetitors);
   const recentRunIds = listRecentAnswerVisibilityRunIds(db, projectId, RECENT_RUNS_WINDOW);
@@ -3474,8 +3611,8 @@ function loadOrchestratorInput(db, project) {
     inProgressActions: /* @__PURE__ */ new Map()
   };
 }
-function listKeywords(db, projectId) {
-  const rows = db.select({ text: keywords.keyword }).from(keywords).where(eq12(keywords.projectId, projectId)).all();
+function listQueries(db, projectId) {
+  const rows = db.select({ text: queries.query }).from(queries).where(eq12(queries.projectId, projectId)).all();
   return rows.map((r) => r.text);
 }
 function listCompetitorDomains(db, projectId) {
@@ -3528,21 +3665,21 @@ function buildCandidateQueries(opts) {
   if (opts.candidateQueryStrings.length === 0 || opts.recentRunIds.length === 0) {
     return opts.candidateQueryStrings.map((query) => emptyCandidate(query));
   }
-  const keywordRows = opts.db.select({ id: keywords.id, text: keywords.keyword }).from(keywords).where(eq12(keywords.projectId, opts.projectId)).all();
-  const keywordIdByText = new Map(keywordRows.map((r) => [r.text, r.id]));
-  const candidateKeywordIds = opts.candidateQueryStrings.map((q) => keywordIdByText.get(q)).filter((id) => Boolean(id));
-  const snapshotRows = opts.db.select().from(querySnapshots).where(inArray3(querySnapshots.runId, opts.recentRunIds)).all().filter((r) => candidateKeywordIds.includes(r.keywordId));
-  const snapshotsByKeyword = /* @__PURE__ */ new Map();
+  const queryRows = opts.db.select({ id: queries.id, text: queries.query }).from(queries).where(eq12(queries.projectId, opts.projectId)).all();
+  const queryIdByText = new Map(queryRows.map((r) => [r.text, r.id]));
+  const candidateQueryIds = opts.candidateQueryStrings.map((q) => queryIdByText.get(q)).filter((id) => Boolean(id));
+  const snapshotRows = opts.db.select().from(querySnapshots).where(inArray3(querySnapshots.runId, opts.recentRunIds)).all().filter((r) => candidateQueryIds.includes(r.queryId));
+  const snapshotsByQuery = /* @__PURE__ */ new Map();
   for (const row of snapshotRows) {
-    const list = snapshotsByKeyword.get(row.keywordId) ?? [];
+    const list = snapshotsByQuery.get(row.queryId) ?? [];
     list.push(row);
-    snapshotsByKeyword.set(row.keywordId, list);
+    snapshotsByQuery.set(row.queryId, list);
   }
   const gscRows = opts.db.select().from(gscSearchData).where(eq12(gscSearchData.projectId, opts.projectId)).all();
   const gscByQuery = aggregateGscByQuery(gscRows);
   return opts.candidateQueryStrings.map((query) => {
-    const keywordId = keywordIdByText.get(query);
-    const snaps = keywordId ? snapshotsByKeyword.get(keywordId) ?? [] : [];
+    const queryId = queryIdByText.get(query);
+    const snaps = queryId ? snapshotsByQuery.get(queryId) ?? [] : [];
     const gsc = gscByQuery.get(query) ?? null;
     return aggregateCandidate({
       query,
@@ -3736,7 +3873,7 @@ function loadSnapshotsForRun(db, runId) {
   return rows.map((r) => ({
     id: r.id,
     runId: r.runId,
-    keywordId: r.keywordId,
+    queryId: r.queryId,
     provider: r.provider,
     model: r.model,
     citationState: r.citationState,
@@ -3748,37 +3885,37 @@ function loadSnapshotsForRun(db, runId) {
     createdAt: r.createdAt
   }));
 }
-function loadKeywordLookup(db, projectId) {
-  const rows = db.select().from(keywords).where(eq13(keywords.projectId, projectId)).all();
+function loadQueryLookup(db, projectId) {
+  const rows = db.select().from(queries).where(eq13(queries.projectId, projectId)).all();
   const byId = /* @__PURE__ */ new Map();
-  for (const row of rows) byId.set(row.id, row.keyword);
+  for (const row of rows) byId.set(row.id, row.query);
   return { byId };
 }
-function buildCitationScorecard(snapshots, keywordLookup) {
+function buildCitationScorecard(snapshots, queryLookup) {
   if (snapshots.length === 0) {
-    return { keywords: [], providers: [], matrix: [], providerRates: [] };
+    return { queries: [], providers: [], matrix: [], providerRates: [] };
   }
-  const keywordSet = /* @__PURE__ */ new Set();
+  const querySet = /* @__PURE__ */ new Set();
   const providerSet = /* @__PURE__ */ new Set();
   for (const snap of snapshots) {
-    const kw = keywordLookup.byId.get(snap.keywordId);
-    if (!kw) continue;
-    keywordSet.add(kw);
+    const q = queryLookup.byId.get(snap.queryId);
+    if (!q) continue;
+    querySet.add(q);
     providerSet.add(snap.provider);
   }
-  const keywordList = [...keywordSet].sort();
+  const queryList = [...querySet].sort();
   const providerList = [...providerSet].sort();
-  const matrix = keywordList.map(
+  const matrix = queryList.map(
     () => providerList.map(() => null)
   );
   const providerCounts = /* @__PURE__ */ new Map();
   for (const snap of snapshots) {
-    const kw = keywordLookup.byId.get(snap.keywordId);
-    if (!kw) continue;
-    const ki = keywordList.indexOf(kw);
+    const q = queryLookup.byId.get(snap.queryId);
+    if (!q) continue;
+    const qi = queryList.indexOf(q);
     const pi = providerList.indexOf(snap.provider);
-    if (ki < 0 || pi < 0) continue;
-    matrix[ki][pi] = {
+    if (qi < 0 || pi < 0) continue;
+    matrix[qi][pi] = {
       citationState: snap.citationState === "cited" ? "cited" : "not-cited",
       answerMentioned: snap.answerMentioned ?? null,
       model: snap.model
@@ -3798,16 +3935,16 @@ function buildCitationScorecard(snapshots, keywordLookup) {
       citationRate
     };
   });
-  return { keywords: keywordList, providers: providerList, matrix, providerRates };
+  return { queries: queryList, providers: providerList, matrix, providerRates };
 }
-function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains, keywordLookup) {
+function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains, queryLookup) {
   let projectCitationCount = 0;
   const competitorMap = /* @__PURE__ */ new Map();
   for (const c of competitorDomains) {
-    competitorMap.set(c, { count: 0, keywords: /* @__PURE__ */ new Set(), pages: /* @__PURE__ */ new Map() });
+    competitorMap.set(c, { count: 0, queries: /* @__PURE__ */ new Set(), pages: /* @__PURE__ */ new Map() });
   }
   for (const snap of snapshots) {
-    const kw = keywordLookup.byId.get(snap.keywordId);
+    const q = queryLookup.byId.get(snap.queryId);
     const allDomains = [...snap.citedDomains, ...snap.competitorOverlap];
     if (allDomains.some((d) => citedDomainBelongsToProject(d, projectDomains))) {
       projectCitationCount++;
@@ -3816,7 +3953,7 @@ function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains,
       if (allDomains.some((d) => citedDomainBelongsToProject(d, [competitor]))) {
         const entry = competitorMap.get(competitor);
         entry.count++;
-        if (kw) entry.keywords.add(kw);
+        if (q) entry.queries.add(q);
       }
       const competitorNorm = normalizeDomain(competitor);
       for (const gs of snap.groundingSources) {
@@ -3824,9 +3961,9 @@ function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains,
         if (!host) continue;
         if (host === competitorNorm || host.endsWith(`.${competitorNorm}`)) {
           const entry = competitorMap.get(competitor);
-          const pageKeywords = entry.pages.get(gs.uri) ?? /* @__PURE__ */ new Set();
-          if (kw) pageKeywords.add(kw);
-          entry.pages.set(gs.uri, pageKeywords);
+          const pageQueries = entry.pages.get(gs.uri) ?? /* @__PURE__ */ new Set();
+          if (q) pageQueries.add(q);
+          entry.pages.set(gs.uri, pageQueries);
         }
       }
     }
@@ -3842,13 +3979,13 @@ function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains,
       else pressureLabel = "Low";
     }
     const sharePct = totalCitedSlots > 0 ? Math.round(data.count / totalCitedSlots * 100) : 0;
-    const theirCitedPages = [...data.pages.entries()].map(([url, kws]) => ({ url, citedFor: [...kws].sort() })).sort((a, b) => b.citedFor.length - a.citedFor.length);
+    const theirCitedPages = [...data.pages.entries()].map(([url, qs]) => ({ url, citedFor: [...qs].sort() })).sort((a, b) => b.citedFor.length - a.citedFor.length);
     return {
       domain,
       citationCount: data.count,
       totalCount: total,
       pressureLabel,
-      citedKeywords: [...data.keywords].sort(),
+      citedQueries: [...data.queries].sort(),
       sharePct,
       theirCitedPages
     };
@@ -3856,18 +3993,18 @@ function buildCompetitorLandscape(snapshots, competitorDomains, projectDomains,
   competitorRows.sort((a, b) => b.citationCount - a.citationCount);
   return { projectCitationCount, competitors: competitorRows };
 }
-function buildMentionLandscape(snapshots, competitorDomains, projectDisplayName, projectDomains, keywordLookup) {
+function buildMentionLandscape(snapshots, competitorDomains, projectDisplayName, projectDomains, queryLookup) {
   let projectMentionCount = 0;
   let totalAnswerSnapshots = 0;
   const competitorMap = /* @__PURE__ */ new Map();
   for (const c of competitorDomains) {
-    competitorMap.set(c, { count: 0, keywords: /* @__PURE__ */ new Set() });
+    competitorMap.set(c, { count: 0, queries: /* @__PURE__ */ new Set() });
   }
   for (const snap of snapshots) {
     const text = snap.answerText;
     if (!text) continue;
     totalAnswerSnapshots++;
-    const kw = keywordLookup.byId.get(snap.keywordId);
+    const q = queryLookup.byId.get(snap.queryId);
     const projectMentioned = snap.answerMentioned ?? determineAnswerMentioned(
       text,
       projectDisplayName,
@@ -3880,7 +4017,7 @@ function buildMentionLandscape(snapshots, competitorDomains, projectDisplayName,
       if (mentioned) {
         const entry = competitorMap.get(competitor);
         entry.count++;
-        if (kw) entry.keywords.add(kw);
+        if (q) entry.queries.add(q);
       }
     }
   }
@@ -3899,7 +4036,7 @@ function buildMentionLandscape(snapshots, competitorDomains, projectDisplayName,
       mentionCount: data.count,
       totalCount: totalAnswerSnapshots,
       pressureLabel,
-      mentionedKeywords: [...data.keywords].sort(),
+      mentionedQueries: [...data.queries].sort(),
       sharePct
     };
   });
@@ -3934,7 +4071,7 @@ function buildAiSourceOrigin(snapshots, projectDomains, competitorDomains) {
   })).sort((a, b) => b.count - a.count).slice(0, TOP_SOURCE_DOMAINS_LIMIT);
   return { categories, topDomains };
 }
-function buildGscSection(db, projectId, projectDisplayName, canonicalDomain, trackedKeywords) {
+function buildGscSection(db, projectId, projectDisplayName, canonicalDomain, trackedQueries) {
   const rows = db.select().from(gscSearchData).where(eq13(gscSearchData.projectId, projectId)).all();
   if (rows.length === 0) return null;
   let totalClicks = 0;
@@ -3981,9 +4118,9 @@ function buildGscSection(db, projectId, projectDisplayName, canonicalDomain, tra
     sharePct: totalClicks > 0 ? Math.round(agg.clicks / totalClicks * 100) : 0
   })).sort((a, b) => b.clicks - a.clicks);
   const trend = [...trendAgg.entries()].map(([date, agg]) => ({ date, clicks: agg.clicks, impressions: agg.impressions })).sort((a, b) => a.date.localeCompare(b.date));
-  const trackedSet = new Set(trackedKeywords.map((k) => k.toLowerCase()));
+  const trackedSet = new Set(trackedQueries.map((q) => q.toLowerCase()));
   const gscQuerySet = new Set([...queryAgg.keys()].map((q) => q.toLowerCase()));
-  const trackedButNoGsc = trackedKeywords.filter((k) => !gscQuerySet.has(k.toLowerCase())).sort();
+  const trackedButNoGsc = trackedQueries.filter((q) => !gscQuerySet.has(q.toLowerCase())).sort();
   const gscButNotTracked = [...queryAgg.entries()].filter(([q]) => !trackedSet.has(q.toLowerCase())).filter(([q]) => categorizeQuery(q, projectDisplayName, canonicalDomain) !== "brand").sort((a, b) => b[1].impressions - a[1].impressions).map(([q]) => q).slice(0, TOP_QUERIES_LIMIT);
   return {
     totalClicks,
@@ -4169,7 +4306,7 @@ function buildIndexingHealth(db, projectId) {
   }
   return null;
 }
-function buildCitationsTrend(db, projectId, keywordLookup) {
+function buildCitationsTrend(db, projectId, queryLookup) {
   const visibilityRuns = db.select().from(runs).where(and4(eq13(runs.projectId, projectId), eq13(runs.kind, RunKinds["answer-visibility"]))).all();
   const points = [];
   for (const run of visibilityRuns) {
@@ -4180,7 +4317,7 @@ function buildCitationsTrend(db, projectId, keywordLookup) {
     let considered = 0;
     const providerCounts = /* @__PURE__ */ new Map();
     for (const snap of snaps) {
-      if (!keywordLookup.byId.has(snap.keywordId)) continue;
+      if (!queryLookup.byId.has(snap.queryId)) continue;
       considered++;
       if (snap.citationState === "cited") cited++;
       const counts = providerCounts.get(snap.provider) ?? { cited: 0, total: 0 };
@@ -4230,7 +4367,7 @@ function buildInsightList(db, projectId) {
       type: r.type,
       severity: r.severity,
       title: r.title,
-      keyword: r.keyword,
+      query: r.query,
       provider: r.provider,
       recommendation: recText,
       createdAt: r.createdAt,
@@ -4246,7 +4383,7 @@ function buildInsightList(db, projectId) {
       type: rep.type,
       severity: rep.severity,
       title: rep.title,
-      keyword: rep.keyword,
+      query: rep.query,
       provider: rep.provider,
       recommendation: rep.recommendation,
       createdAt: rep.createdAt,
@@ -4332,7 +4469,7 @@ function buildExecutiveFindings(citationRate, trend, trendsPoints, trendBaseline
 }
 function buildProjectReport(db, projectName) {
   const project = resolveProject(db, projectName);
-  const keywordLookup = loadKeywordLookup(db, project.id);
+  const queryLookup = loadQueryLookup(db, project.id);
   const allRuns = db.select().from(runs).where(eq13(runs.projectId, project.id)).orderBy(desc6(runs.createdAt)).all();
   const visibilityRuns = allRuns.filter((r) => r.kind === RunKinds["answer-visibility"]);
   const latestRun = visibilityRuns.find(
@@ -4343,34 +4480,34 @@ function buildProjectReport(db, projectName) {
   const competitorDomains = competitorRows.map((c) => c.domain);
   const ownedDomains = parseJsonColumn(project.ownedDomains, []);
   const projectDomains = [project.canonicalDomain, ...ownedDomains];
-  const citationScorecard = buildCitationScorecard(latestSnapshots, keywordLookup);
+  const citationScorecard = buildCitationScorecard(latestSnapshots, queryLookup);
   const competitorLandscape = buildCompetitorLandscape(
     latestSnapshots,
     competitorDomains,
     projectDomains,
-    keywordLookup
+    queryLookup
   );
   const mentionLandscape = buildMentionLandscape(
     latestSnapshots,
     competitorDomains,
     project.displayName,
     projectDomains,
-    keywordLookup
+    queryLookup
   );
   const aiSourceOrigin = buildAiSourceOrigin(latestSnapshots, projectDomains, competitorDomains);
-  const trackedKeywords = [...keywordLookup.byId.values()];
+  const trackedQueries = [...queryLookup.byId.values()];
   const gscSection = buildGscSection(
     db,
     project.id,
     project.displayName,
     project.canonicalDomain,
-    trackedKeywords
+    trackedQueries
   );
   const gaSection = buildGaSection(db, project.id);
   const socialSection = buildSocialReferrals(db, project.id);
   const aiReferralsSection = buildAiReferrals(db, project.id);
   const indexingHealthSection = buildIndexingHealth(db, project.id);
-  const citationsTrend = buildCitationsTrend(db, project.id, keywordLookup);
+  const citationsTrend = buildCitationsTrend(db, project.id, queryLookup);
   const insightList = buildInsightList(db, project.id);
   const orchestratorInput = loadOrchestratorInput(db, project);
   const contentOpportunities = buildContentTargetRows(orchestratorInput);
@@ -4384,7 +4521,7 @@ function buildProjectReport(db, projectName) {
   let latestCited = 0;
   let latestConsidered = 0;
   for (const snap of latestSnapshots) {
-    if (!keywordLookup.byId.has(snap.keywordId)) continue;
+    if (!queryLookup.byId.has(snap.queryId)) continue;
     latestConsidered++;
     if (snap.citationState === "cited") latestCited++;
   }
@@ -4430,7 +4567,7 @@ function buildProjectReport(db, projectName) {
     executiveSummary: {
       citationRate,
       trend,
-      keywordCount: keywordLookup.byId.size,
+      queryCount: queryLookup.byId.size,
       competitorCount: competitorDomains.length,
       providerCount: citationScorecard.providers.length,
       gsc: gscSection ? {
@@ -4489,9 +4626,9 @@ async function citationRoutes(app) {
   app.get("/projects/:name/citations/visibility", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
     const configuredProviders = parseJsonColumn(project.providers, []);
-    const projectKeywords = app.db.select().from(keywords).where(eq14(keywords.projectId, project.id)).all();
-    if (projectKeywords.length === 0) {
-      return reply.send(emptyCitationVisibility("no-keywords"));
+    const projectQueries = app.db.select().from(queries).where(eq14(queries.projectId, project.id)).all();
+    if (projectQueries.length === 0) {
+      return reply.send(emptyCitationVisibility("no-queries"));
     }
     const projectRuns = app.db.select({ id: runs.id, createdAt: runs.createdAt }).from(runs).where(eq14(runs.projectId, project.id)).all();
     if (projectRuns.length === 0) {
@@ -4501,7 +4638,7 @@ async function citationRoutes(app) {
     const rawSnapshots = app.db.select({
       id: querySnapshots.id,
       runId: querySnapshots.runId,
-      keywordId: querySnapshots.keywordId,
+      queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState,
       citedDomains: querySnapshots.citedDomains,
@@ -4518,7 +4655,7 @@ async function citationRoutes(app) {
     }));
     const projectCompetitors = app.db.select({ domain: competitors.domain }).from(competitors).where(eq14(competitors.projectId, project.id)).all().map((c) => normalizeDomain2(c.domain)).filter((d) => d.length > 0);
     const response = computeCitationVisibility({
-      keywords: projectKeywords.map((k) => ({ id: k.id, keyword: k.keyword })),
+      queries: projectQueries.map((q) => ({ id: q.id, query: q.query })),
       snapshots,
       configuredProviders,
       competitorDomains: projectCompetitors
@@ -4527,10 +4664,10 @@ async function citationRoutes(app) {
   });
 }
 function computeCitationVisibility(input) {
-  const { keywords: kws, snapshots, configuredProviders, competitorDomains } = input;
+  const { queries: qs, snapshots, configuredProviders, competitorDomains } = input;
   const latestByPair = /* @__PURE__ */ new Map();
   for (const snap of snapshots) {
-    const key = `${snap.keywordId}::${snap.provider}`;
+    const key = `${snap.queryId}::${snap.provider}`;
     const existing = latestByPair.get(key);
     if (!existing || snap.createdAt > existing.createdAt) {
       latestByPair.set(key, snap);
@@ -4541,17 +4678,17 @@ function computeCitationVisibility(input) {
   const providerUniverse = configuredProviders.length > 0 ? Array.from(new Set(configuredProviders)) : Array.from(observedProviders).sort();
   const providersCitingTracker = /* @__PURE__ */ new Set();
   const providersMentioningTracker = /* @__PURE__ */ new Set();
-  let keywordsCitedAndMentioned = 0;
-  let keywordsCitedOnly = 0;
-  let keywordsMentionedOnly = 0;
-  let keywordsInvisible = 0;
-  const byKeyword = [];
-  for (const kw of kws) {
+  let queriesCitedAndMentioned = 0;
+  let queriesCitedOnly = 0;
+  let queriesMentionedOnly = 0;
+  let queriesInvisible = 0;
+  const byQuery = [];
+  for (const q of qs) {
     const providers = [];
     let citedCount = 0;
     let mentionedCount = 0;
     for (const provider of providerUniverse) {
-      const snap = latestByPair.get(`${kw.id}::${provider}`);
+      const snap = latestByPair.get(`${q.id}::${provider}`);
       if (!snap) continue;
       const state = snap.citationState;
       const cited = citationStateToCited(state);
@@ -4576,14 +4713,14 @@ function computeCitationVisibility(input) {
     if (providers.length > 0) {
       const anyCited = citedCount > 0;
       const anyMentioned = mentionedCount > 0;
-      if (anyCited && anyMentioned) keywordsCitedAndMentioned++;
-      else if (anyCited) keywordsCitedOnly++;
-      else if (anyMentioned) keywordsMentionedOnly++;
-      else keywordsInvisible++;
-    }
-    byKeyword.push({
-      keywordId: kw.id,
-      keyword: kw.keyword,
+      if (anyCited && anyMentioned) queriesCitedAndMentioned++;
+      else if (anyCited) queriesCitedOnly++;
+      else if (anyMentioned) queriesMentionedOnly++;
+      else queriesInvisible++;
+    }
+    byQuery.push({
+      queryId: q.id,
+      query: q.query,
       providers,
       citedCount,
       mentionedCount,
@@ -4592,7 +4729,7 @@ function computeCitationVisibility(input) {
   }
   const competitorSet = new Set(competitorDomains);
   const competitorGaps = [];
-  const keywordById = new Map(kws.map((k) => [k.id, k.keyword]));
+  const queryById = new Map(qs.map((q) => [q.id, q.query]));
   for (const snap of latestByPair.values()) {
     if (citationStateToCited(snap.citationState)) continue;
     if (competitorSet.size === 0) continue;
@@ -4604,8 +4741,8 @@ function computeCitationVisibility(input) {
     const citingCompetitors = Array.from(candidates).filter((d) => competitorSet.has(d));
     if (citingCompetitors.length === 0) continue;
     competitorGaps.push({
-      keywordId: snap.keywordId,
-      keyword: keywordById.get(snap.keywordId) ?? "",
+      queryId: snap.queryId,
+      query: queryById.get(snap.queryId) ?? "",
       provider: snap.provider,
       citingCompetitors: citingCompetitors.sort(),
       runId: snap.runId,
@@ -4613,7 +4750,7 @@ function computeCitationVisibility(input) {
     });
   }
   competitorGaps.sort((a, b) => {
-    if (a.keyword !== b.keyword) return a.keyword.localeCompare(b.keyword);
+    if (a.query !== b.query) return a.query.localeCompare(b.query);
     return a.provider.localeCompare(b.provider);
   });
   let latestRunId = null;
@@ -4628,17 +4765,17 @@ function computeCitationVisibility(input) {
     providersConfigured: providerUniverse.length,
     providersCiting: providersCitingTracker.size,
     providersMentioning: providersMentioningTracker.size,
-    totalKeywords: kws.length,
-    keywordsCitedAndMentioned,
-    keywordsCitedOnly,
-    keywordsMentionedOnly,
-    keywordsInvisible,
+    totalQueries: qs.length,
+    queriesCitedAndMentioned,
+    queriesCitedOnly,
+    queriesMentionedOnly,
+    queriesInvisible,
     latestRunId,
     latestRunAt
   };
   return {
     summary,
-    byKeyword,
+    byQuery,
     competitorGaps,
     status: "ready"
   };
@@ -4664,14 +4801,14 @@ async function compositeRoutes(app) {
     const health = healthRow ? mapHealthRow2(healthRow) : null;
     const insightRows = app.db.select().from(insights).where(eq15(insights.projectId, project.id)).orderBy(desc7(insights.createdAt)).all();
     const topInsights = insightRows.filter((row) => !row.dismissed).slice(0, TOP_INSIGHT_LIMIT).map(mapInsightRow2);
-    const { keywordCounts, providers } = summarizeLatestRun(app, latestRunRow ?? null);
+    const { queryCounts, providers } = summarizeLatestRun(app, latestRunRow ?? null);
     const transitions = summarizeTransitions(app, latestRunRow ?? null, previousRunRow ?? null);
     const result = {
       project: formatProject2(project),
       latestRun,
       health,
       topInsights,
-      keywordCounts,
+      queryCounts,
       providers,
       transitions
     };
@@ -4689,8 +4826,8 @@ async function compositeRoutes(app) {
     const snapshotMatches = app.db.select({
       id: querySnapshots.id,
       runId: querySnapshots.runId,
-      keywordId: querySnapshots.keywordId,
-      keywordText: keywords.keyword,
+      queryId: querySnapshots.queryId,
+      queryText: queries.query,
       provider: querySnapshots.provider,
       model: querySnapshots.model,
       citationState: querySnapshots.citationState,
@@ -4698,14 +4835,14 @@ async function compositeRoutes(app) {
       citedDomains: querySnapshots.citedDomains,
       rawResponse: querySnapshots.rawResponse,
       createdAt: querySnapshots.createdAt
-    }).from(querySnapshots).innerJoin(keywords, eq15(querySnapshots.keywordId, keywords.id)).where(
+    }).from(querySnapshots).innerJoin(queries, eq15(querySnapshots.queryId, queries.id)).where(
       and5(
-        eq15(keywords.projectId, project.id),
+        eq15(queries.projectId, project.id),
         or3(
           sql3`${querySnapshots.answerText} LIKE ${pattern} ESCAPE '\\'`,
           sql3`${querySnapshots.citedDomains} LIKE ${pattern} ESCAPE '\\'`,
           sql3`${querySnapshots.rawResponse} LIKE ${pattern} ESCAPE '\\'`,
-          like(keywords.keyword, pattern)
+          like(queries.query, pattern)
         )
       )
     ).orderBy(desc7(querySnapshots.createdAt)).limit(limit + 1).all();
@@ -4714,7 +4851,7 @@ async function compositeRoutes(app) {
         eq15(insights.projectId, project.id),
         or3(
           like(insights.title, pattern),
-          like(insights.keyword, pattern),
+          like(insights.query, pattern),
           sql3`${insights.recommendation} LIKE ${pattern} ESCAPE '\\'`,
           sql3`${insights.cause} LIKE ${pattern} ESCAPE '\\'`
         )
@@ -4766,35 +4903,35 @@ function summarizeRun(run) {
 }
 function summarizeLatestRun(app, run) {
   const empty = {
-    keywordCounts: { totalKeywords: 0, citedKeywords: 0, notCitedKeywords: 0, citedRate: 0 },
+    queryCounts: { totalQueries: 0, citedQueries: 0, notCitedQueries: 0, citedRate: 0 },
     providers: []
   };
   if (!run) return empty;
   const rows = app.db.select({
-    keywordId: querySnapshots.keywordId,
+    queryId: querySnapshots.queryId,
     provider: querySnapshots.provider,
     citationState: querySnapshots.citationState
   }).from(querySnapshots).where(eq15(querySnapshots.runId, run.id)).all();
   if (rows.length === 0) return empty;
-  const perKeyword = /* @__PURE__ */ new Map();
+  const perQuery = /* @__PURE__ */ new Map();
   const perProvider = /* @__PURE__ */ new Map();
   for (const row of rows) {
     const cited = row.citationState === "cited";
-    if (!perKeyword.has(row.keywordId) || cited) {
-      perKeyword.set(row.keywordId, cited);
+    if (!perQuery.has(row.queryId) || cited) {
+      perQuery.set(row.queryId, cited);
     }
     const bucket = perProvider.get(row.provider) ?? { cited: 0, total: 0 };
     bucket.total += 1;
     if (cited) bucket.cited += 1;
     perProvider.set(row.provider, bucket);
   }
-  const totalKeywords = perKeyword.size;
-  let citedKeywords = 0;
-  for (const wasCited of perKeyword.values()) {
-    if (wasCited) citedKeywords += 1;
+  const totalQueries = perQuery.size;
+  let citedQueries = 0;
+  for (const wasCited of perQuery.values()) {
+    if (wasCited) citedQueries += 1;
   }
-  const notCitedKeywords = totalKeywords - citedKeywords;
-  const citedRate = totalKeywords === 0 ? 0 : Number((citedKeywords / totalKeywords).toFixed(4));
+  const notCitedQueries = totalQueries - citedQueries;
+  const citedRate = totalQueries === 0 ? 0 : Number((citedQueries / totalQueries).toFixed(4));
   const providers = [...perProvider.entries()].map(([provider, { cited, total }]) => ({
     provider,
     cited,
@@ -4802,7 +4939,7 @@ function summarizeLatestRun(app, run) {
     citedRate: total === 0 ? 0 : Number((cited / total).toFixed(4))
   })).sort((a, b) => a.provider.localeCompare(b.provider));
   return {
-    keywordCounts: { totalKeywords, citedKeywords, notCitedKeywords, citedRate },
+    queryCounts: { totalQueries, citedQueries, notCitedQueries, citedRate },
     providers
   };
 }
@@ -4811,13 +4948,13 @@ function summarizeTransitions(app, latest, previous) {
   if (!latest || !previous) return empty;
   const fetchCited = (runId) => {
     const rows = app.db.select({
-      keywordId: querySnapshots.keywordId,
+      queryId: querySnapshots.queryId,
       citationState: querySnapshots.citationState
     }).from(querySnapshots).where(eq15(querySnapshots.runId, runId)).all();
     const map = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const cited = row.citationState === "cited";
-      if (!map.has(row.keywordId) || cited) map.set(row.keywordId, cited);
+      if (!map.has(row.queryId) || cited) map.set(row.queryId, cited);
     }
     return map;
   };
@@ -4826,8 +4963,8 @@ function summarizeTransitions(app, latest, previous) {
   let gained = 0;
   let lost = 0;
   let emerging = 0;
-  for (const [keywordId, latestCited] of latestMap) {
-    const previousCited = previousMap.get(keywordId);
+  for (const [queryId, latestCited] of latestMap) {
+    const previousCited = previousMap.get(queryId);
     if (previousCited === void 0) {
       if (latestCited) emerging += 1;
       continue;
@@ -4845,7 +4982,7 @@ function mapInsightRow2(r) {
     type: r.type,
     severity: r.severity,
     title: r.title,
-    keyword: r.keyword,
+    query: r.query,
     provider: r.provider,
     recommendation: parseJsonColumn(r.recommendation, void 0),
     cause: parseJsonColumn(r.cause, void 0),
@@ -4886,9 +5023,9 @@ function formatProject2(row) {
     updatedAt: row.updatedAt
   };
 }
-function buildSnapshotHit(row, query) {
-  const lower = query.toLowerCase();
-  const keyword = row.keywordText ?? "";
+function buildSnapshotHit(row, searchTerm) {
+  const lower = searchTerm.toLowerCase();
+  const query = row.queryText ?? "";
   const answer = row.answerText ?? "";
   const cited = row.citedDomains;
   const raw = row.rawResponse ?? "";
@@ -4896,22 +5033,22 @@ function buildSnapshotHit(row, query) {
   let snippet;
   if (answer.toLowerCase().includes(lower)) {
     matchedField = "answerText";
-    snippet = makeSnippet(answer, query);
+    snippet = makeSnippet(answer, searchTerm);
   } else if (cited.toLowerCase().includes(lower)) {
     matchedField = "citedDomains";
-    snippet = makeSnippet(cited, query);
+    snippet = makeSnippet(cited, searchTerm);
   } else if (raw.toLowerCase().includes(lower)) {
     matchedField = "searchQueries";
-    snippet = makeSnippet(raw, query);
+    snippet = makeSnippet(raw, searchTerm);
   } else {
-    matchedField = "keyword";
-    snippet = keyword;
+    matchedField = "query";
+    snippet = query;
   }
   return {
     kind: "snapshot",
     id: row.id,
     runId: row.runId,
-    keyword,
+    query,
     provider: row.provider,
     model: row.model,
     citationState: row.citationState,
@@ -4920,24 +5057,24 @@ function buildSnapshotHit(row, query) {
     createdAt: row.createdAt
   };
 }
-function buildInsightHit(row, query) {
-  const lower = query.toLowerCase();
+function buildInsightHit(row, searchTerm) {
+  const lower = searchTerm.toLowerCase();
   const recommendation = row.recommendation ?? "";
   const cause = row.cause ?? "";
   let matchedField;
   let snippet;
   if (row.title.toLowerCase().includes(lower)) {
     matchedField = "title";
-    snippet = makeSnippet(row.title, query);
-  } else if (row.keyword.toLowerCase().includes(lower)) {
-    matchedField = "keyword";
-    snippet = row.keyword;
+    snippet = makeSnippet(row.title, searchTerm);
+  } else if (row.query.toLowerCase().includes(lower)) {
+    matchedField = "query";
+    snippet = row.query;
   } else if (recommendation.toLowerCase().includes(lower)) {
     matchedField = "recommendation";
-    snippet = makeSnippet(recommendation, query);
+    snippet = makeSnippet(recommendation, searchTerm);
   } else {
     matchedField = "cause";
-    snippet = makeSnippet(cause, query);
+    snippet = makeSnippet(cause, searchTerm);
   }
   return {
     kind: "insight",
@@ -4946,7 +5083,7 @@ function buildInsightHit(row, query) {
     type: row.type,
     severity: row.severity,
     title: row.title,
-    keyword: row.keyword,
+    query: row.query,
     provider: row.provider,
     matchedField,
     snippet,
@@ -5292,21 +5429,130 @@ var routeCatalog = [
       404: { description: "Project not found." }
     }
   },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/queries",
+    summary: "List queries",
+    tags: ["queries"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Queries returned." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/projects/{name}/queries",
+    summary: "Replace queries",
+    tags: ["queries"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["queries"],
+            properties: {
+              queries: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Queries replaced." }
+    }
+  },
+  {
+    method: "delete",
+    path: "/api/v1/projects/{name}/queries",
+    summary: "Delete specific queries",
+    tags: ["queries"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["queries"],
+            properties: {
+              queries: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Remaining queries returned." },
+      400: { description: "Invalid query delete request." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/queries",
+    summary: "Append queries",
+    tags: ["queries"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["queries"],
+            properties: {
+              queries: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Queries appended." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/queries/generate",
+    summary: "Generate query suggestions",
+    tags: ["queries"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["provider"],
+            properties: {
+              provider: { type: "string", enum: ["gemini", "openai", "claude", "perplexity", "local"] },
+              count: integerSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Query suggestions returned." },
+      501: { description: "Query generation is not available." }
+    }
+  },
   {
     method: "get",
     path: "/api/v1/projects/{name}/keywords",
-    summary: "List keywords",
-    tags: ["keywords"],
+    summary: "List keywords (legacy alias for queries)",
+    tags: ["queries"],
     parameters: [nameParameter],
     responses: {
-      200: { description: "Keywords returned." }
+      200: { description: "Legacy keyword-shaped queries returned." }
     }
   },
   {
     method: "put",
     path: "/api/v1/projects/{name}/keywords",
-    summary: "Replace keywords",
-    tags: ["keywords"],
+    summary: "Replace keywords (legacy alias for queries)",
+    tags: ["queries"],
     parameters: [nameParameter],
     requestBody: {
       required: true,
@@ -5323,14 +5569,14 @@ var routeCatalog = [
       }
     },
     responses: {
-      200: { description: "Keywords replaced." }
+      200: { description: "Legacy keyword-shaped queries replaced." }
     }
   },
   {
     method: "delete",
     path: "/api/v1/projects/{name}/keywords",
-    summary: "Delete specific keywords",
-    tags: ["keywords"],
+    summary: "Delete keywords (legacy alias for queries)",
+    tags: ["queries"],
     parameters: [nameParameter],
     requestBody: {
       required: true,
@@ -5347,15 +5593,15 @@ var routeCatalog = [
       }
     },
     responses: {
-      200: { description: "Remaining keywords returned." },
-      400: { description: "Invalid keyword delete request." }
+      200: { description: "Remaining legacy keyword-shaped queries returned." },
+      400: { description: "Invalid legacy keyword delete request." }
     }
   },
   {
     method: "post",
     path: "/api/v1/projects/{name}/keywords",
-    summary: "Append keywords",
-    tags: ["keywords"],
+    summary: "Append keywords (legacy alias for queries)",
+    tags: ["queries"],
     parameters: [nameParameter],
     requestBody: {
       required: true,
@@ -5372,14 +5618,14 @@ var routeCatalog = [
       }
     },
     responses: {
-      200: { description: "Keywords appended." }
+      200: { description: "Legacy keyword-shaped queries appended." }
     }
   },
   {
     method: "post",
     path: "/api/v1/projects/{name}/keywords/generate",
-    summary: "Generate keyword suggestions",
-    tags: ["keywords"],
+    summary: "Generate keyword suggestions (legacy alias for queries)",
+    tags: ["queries"],
     parameters: [nameParameter],
     requestBody: {
       required: true,
@@ -5397,8 +5643,8 @@ var routeCatalog = [
       }
     },
     responses: {
-      200: { description: "Keyword suggestions returned." },
-      501: { description: "Keyword generation is not available." }
+      200: { description: "Legacy keyword suggestions returned." },
+      501: { description: "Legacy keyword generation is not available." }
     }
   },
   {
@@ -5643,7 +5889,7 @@ var routeCatalog = [
   {
     method: "get",
     path: "/api/v1/projects/{name}/timeline",
-    summary: "Get keyword timeline",
+    summary: "Get query timeline",
     tags: ["history"],
     parameters: [nameParameter, locationQueryParameter],
     responses: {
@@ -5788,7 +6034,7 @@ var routeCatalog = [
             properties: {
               companyName: stringSchema,
               domain: stringSchema,
-              phrases: stringArraySchema,
+              queries: stringArraySchema,
               competitors: stringArraySchema
             }
           }
@@ -7276,8 +7522,8 @@ var routeCatalog = [
   {
     method: "get",
     path: "/api/v1/projects/{name}/citations/visibility",
-    summary: "Citation visibility headline (citation + answer-mention, by engine + keyword)",
-    description: 'Single-call read for the AI citation surface. Returns two parallel headline metrics (`providersCiting` = engines that cite the project in their grounding/source list, `providersMentioning` = engines that name the project in answer prose), per-keyword cross-tab buckets (`keywordsCitedAndMentioned` / `keywordsCitedOnly` / `keywordsMentionedOnly` / `keywordsInvisible` \u2014 mutually exclusive over keywords that have at least one snapshot), per-keyword engine coverage rows from the latest snapshot per (keyword \xD7 provider) with both `cited` and `mentioned` flags, and a competitor-gap list (keywords where the project is not cited but a configured competitor is). Status `no-data` with `reason: "no-runs-yet"` or `"no-keywords"` when the project lacks the inputs.',
+    summary: "Citation visibility headline (citation + answer-mention, by engine + query)",
+    description: 'Single-call read for the AI citation surface. Returns two parallel headline metrics (`providersCiting` = engines that cite the project in their grounding/source list, `providersMentioning` = engines that name the project in answer prose), per-query cross-tab buckets (`queriesCitedAndMentioned` / `queriesCitedOnly` / `queriesMentionedOnly` / `queriesInvisible` \u2014 mutually exclusive over queries that have at least one snapshot), per-query engine coverage rows from the latest snapshot per (query \xD7 provider) with both `cited` and `mentioned` flags, and a competitor-gap list (queries where the project is not cited but a configured competitor is). Status `no-data` with `reason: "no-runs-yet"` or `"no-queries"` when the project lacks the inputs.',
     tags: ["intelligence"],
     parameters: [nameParameter],
     responses: {
@@ -7331,7 +7577,7 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/overview",
     summary: "Get a composite overview of project health",
-    description: 'Bundles project info, latest run, top undismissed insights, the latest health snapshot, keyword cited rate, per-provider breakdown, and transitions vs. the previous run. Designed for the "how is project X doing?" question so agents can answer in one call.',
+    description: 'Bundles project info, latest run, top undismissed insights, the latest health snapshot, query cited rate, per-provider breakdown, and transitions vs. the previous run. Designed for the "how is project X doing?" question so agents can answer in one call.',
     tags: ["intelligence"],
     parameters: [nameParameter],
     responses: {
@@ -7343,7 +7589,7 @@ var routeCatalog = [
     method: "get",
     path: "/api/v1/projects/{name}/search",
     summary: "Search query snapshots and insights for text",
-    description: "Returns the most recent snapshots and insights whose answer text, cited domains, raw response, or insight title/keyword/recommendation/cause matches the query. Use to find anything mentioning a competitor, term, or URL without paginating snapshots.",
+    description: "Returns the most recent snapshots and insights whose answer text, cited domains, raw response, or insight title/query/recommendation/cause matches the query. Use to find anything mentioning a competitor, term, or URL without paginating snapshots.",
     tags: ["intelligence"],
     parameters: [
       nameParameter,
@@ -7889,8 +8135,13 @@ async function snapshotRoutes(app, opts) {
     if (!opts.onSnapshotRequested) {
       throw notImplemented("Snapshot reporting is not supported in this deployment");
     }
+    const input = {
+      ...parsed.data,
+      queries: resolveSnapshotRequestQueries(parsed.data)
+    };
+    delete input.phrases;
     try {
-      return await opts.onSnapshotRequested(parsed.data);
+      return await opts.onSnapshotRequested(input);
     } catch (err) {
       request.log.error({ err }, "Snapshot report generation failed");
       throw internalError(err instanceof Error ? err.message : "Failed to generate snapshot report");
@@ -8129,7 +8380,7 @@ async function notificationRoutes(app) {
       project: { name: project.name, canonicalDomain: project.canonicalDomain },
       run: { id: "test-run-id", status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() },
       transitions: [
-        { keyword: "test keyword", from: "not-cited", to: "cited", provider: "gemini" }
+        { query: "test query", from: "not-cited", to: "cited", provider: "gemini" }
       ],
       dashboardUrl: `/projects/${project.name}`
     };
@@ -10534,22 +10785,22 @@ async function cdpRoutes(app, opts) {
       }
       const snapshots = app.db.select({
         id: querySnapshots.id,
-        keywordId: querySnapshots.keywordId,
+        queryId: querySnapshots.queryId,
         provider: querySnapshots.provider,
         citationState: querySnapshots.citationState,
         citedDomains: querySnapshots.citedDomains,
         screenshotPath: querySnapshots.screenshotPath,
         rawResponse: querySnapshots.rawResponse
       }).from(querySnapshots).where(eq20(querySnapshots.runId, runId)).all();
-      const keywordRows = app.db.select({ id: keywords.id, keyword: keywords.keyword }).from(keywords).where(eq20(keywords.projectId, project.id)).all();
-      const keywordMap = new Map(keywordRows.map((k) => [k.id, k.keyword]));
-      const byKeyword = /* @__PURE__ */ new Map();
+      const queryRows = app.db.select({ id: queries.id, query: queries.query }).from(queries).where(eq20(queries.projectId, project.id)).all();
+      const queryMap = new Map(queryRows.map((q) => [q.id, q.query]));
+      const byQuery = /* @__PURE__ */ new Map();
       for (const snap of snapshots) {
-        const kwName = keywordMap.get(snap.keywordId) ?? snap.keywordId;
-        if (!byKeyword.has(snap.keywordId)) {
-          byKeyword.set(snap.keywordId, { keyword: kwName, api: null, browser: null });
+        const qName = queryMap.get(snap.queryId) ?? snap.queryId;
+        if (!byQuery.has(snap.queryId)) {
+          byQuery.set(snap.queryId, { query: qName, api: null, browser: null });
         }
-        const entry = byKeyword.get(snap.keywordId);
+        const entry = byQuery.get(snap.queryId);
         if (snap.provider === "cdp:chatgpt") {
           entry.browser = snap;
         } else if (snap.provider === "openai") {
@@ -10561,7 +10812,7 @@ async function cdpRoutes(app, opts) {
       let browserOnlyCited = 0;
       let disagreed = 0;
       let total = 0;
-      const keywordResults = [...byKeyword.values()].map(({ keyword, api, browser }) => {
+      const queryResults = [...byQuery.values()].map(({ query, api, browser }) => {
         total++;
         const apiCited = api?.citationState === "cited";
         const browserCited = browser?.citationState === "cited";
@@ -10597,17 +10848,17 @@ async function cdpRoutes(app, opts) {
           }
         };
         return {
-          keyword,
+          query,
           api: api ? {
             provider: api.provider,
             citationState: api.citationState,
-            citedDomains: JSON.parse(api.citedDomains || "[]"),
+            citedDomains: parseJsonColumn(api.citedDomains, []),
             groundingSources: parseGroundingSources2(api)
           } : null,
           browser: browser ? {
             provider: browser.provider,
             citationState: browser.citationState,
-            citedDomains: JSON.parse(browser.citedDomains || "[]"),
+            citedDomains: parseJsonColumn(browser.citedDomains, []),
             groundingSources: parseGroundingSources2(browser),
             screenshotUrl: browser.screenshotPath ? `${opts.routePrefix ?? "/api/v1"}/screenshots/${browser.id}` : void 0
           } : null,
@@ -10616,7 +10867,7 @@ async function cdpRoutes(app, opts) {
       });
       return reply.send({
         summary: { total, agreed, apiOnly: apiOnlyCited, browserOnly: browserOnlyCited, disagreed },
-        keywords: keywordResults
+        queries: queryResults
       });
     }
   );
@@ -14491,8 +14742,8 @@ async function apiRoutes(app, opts) {
       onProjectUpserted: opts.onProjectUpserted,
       validProviderNames: opts.providerAdapters?.map((a) => a.name)
     });
-    await api.register(keywordRoutes, {
-      onGenerateKeywords: opts.onGenerateKeywords,
+    await api.register(queryRoutes, {
+      onGenerateQueries: opts.onGenerateQueries,
       validProviderNames: opts.providerAdapters?.filter((a) => a.mode === "api").map((a) => a.name)
     });
     await api.register(competitorRoutes);
@@ -14706,7 +14957,7 @@ async function healthcheck(config) {
 }
 async function executeTrackedQuery(input) {
   const model = resolveModel(input.config);
-  const prompt = buildPrompt(input.keyword, input.location);
+  const prompt = buildPrompt(input.query, input.location);
   const client = createClient(input.config);
   try {
     const result = await withRetry(
@@ -14760,11 +15011,11 @@ function reparseStoredResult(rawResponse) {
     searchQueries
   };
 }
-function buildPrompt(keyword, location) {
+function buildPrompt(query, location) {
   if (location) {
-    return `${keyword} (searching from ${location.city}, ${location.region}, ${location.country})`;
+    return `${query} (searching from ${location.city}, ${location.region}, ${location.country})`;
   }
-  return keyword;
+  return query;
 }
 function extractAnswerText(rawResponse) {
   try {
@@ -14953,7 +15204,7 @@ var geminiAdapter = {
   },
   async executeTrackedQuery(input, config) {
     const raw = await executeTrackedQuery({
-      keyword: input.keyword,
+      query: input.query,
       canonicalDomains: input.canonicalDomains,
       competitorDomains: input.competitorDomains,
       config: toGeminiConfig(config),
@@ -15087,7 +15338,7 @@ async function executeTrackedQuery2(input) {
         model,
         tools: [webSearchTool],
         tool_choice: "required",
-        input: buildPrompt2(input.keyword)
+        input: buildPrompt2(input.query)
       })
     );
     const rawResponse = responseToRecord2(response);
@@ -15132,8 +15383,8 @@ function reparseStoredResult2(rawResponse) {
     searchQueries
   };
 }
-function buildPrompt2(keyword) {
-  return keyword;
+function buildPrompt2(query) {
+  return query;
 }
 function extractResponseText(response) {
   try {
@@ -15180,7 +15431,7 @@ function extractGroundingSourcesFromRaw(rawResponse) {
   return sources;
 }
 function extractSearchQueriesFromRaw2(rawResponse) {
-  const queries = /* @__PURE__ */ new Set();
+  const queries2 = /* @__PURE__ */ new Set();
   try {
     const output = rawResponse.output;
     if (!output) return [];
@@ -15188,19 +15439,19 @@ function extractSearchQueriesFromRaw2(rawResponse) {
       if (item.type !== "web_search_call" || !item.action) continue;
       const action = item.action;
       if (typeof action.query === "string" && action.query.length > 0) {
-        queries.add(action.query);
+        queries2.add(action.query);
       }
       if (Array.isArray(action.queries)) {
         for (const query of action.queries) {
           if (typeof query === "string" && query.length > 0) {
-            queries.add(query);
+            queries2.add(query);
           }
         }
       }
     }
   } catch {
   }
-  return [...queries];
+  return [...queries2];
 }
 function extractAnswerTextFromRaw(rawResponse) {
   try {
@@ -15307,7 +15558,7 @@ var openaiAdapter = {
   },
   async executeTrackedQuery(input, config) {
     const raw = await executeTrackedQuery2({
-      keyword: input.keyword,
+      query: input.query,
       canonicalDomains: input.canonicalDomains,
       competitorDomains: input.competitorDomains,
       config: toOpenAIConfig(config),
@@ -15459,7 +15710,7 @@ async function executeTrackedQuery3(input) {
         model,
         max_tokens: 4096,
         tools: [webSearchTool],
-        messages: [{ role: "user", content: input.keyword }]
+        messages: [{ role: "user", content: input.query }]
       })
     );
     const rawResponse = responseToRecord3(response);
@@ -15546,19 +15797,19 @@ function extractGroundingSourcesFromRaw2(rawResponse) {
   return sources;
 }
 function extractSearchQueriesFromRaw3(rawResponse) {
-  const queries = /* @__PURE__ */ new Set();
+  const queries2 = /* @__PURE__ */ new Set();
   try {
     const content = rawResponse.content;
     if (!content) return [];
     for (const block of content) {
       if (block.type === "server_tool_use" && block.name === "web_search") {
         if (typeof block.input?.query === "string" && block.input.query.length > 0) {
-          queries.add(block.input.query);
+          queries2.add(block.input.query);
         }
         if (Array.isArray(block.input?.queries)) {
           for (const query of block.input.queries) {
             if (typeof query === "string" && query.length > 0) {
-              queries.add(query);
+              queries2.add(query);
             }
           }
         }
@@ -15566,7 +15817,7 @@ function extractSearchQueriesFromRaw3(rawResponse) {
     }
   } catch {
   }
-  return [...queries];
+  return [...queries2];
 }
 function extractAnswerTextFromRaw2(rawResponse) {
   try {
@@ -15684,7 +15935,7 @@ var claudeAdapter = {
   },
   async executeTrackedQuery(input, config) {
     const raw = await executeTrackedQuery3({
-      keyword: input.keyword,
+      query: input.query,
       canonicalDomains: input.canonicalDomains,
       competitorDomains: input.competitorDomains,
       config: toClaudeConfig(config),
@@ -15821,7 +16072,7 @@ async function executeTrackedQuery4(input) {
           },
           {
             role: "user",
-            content: buildPrompt3(input.keyword, input.location)
+            content: buildPrompt3(input.query, input.location)
           }
         ]
       })
@@ -15853,9 +16104,9 @@ function normalizeResult4(raw) {
     searchQueries: raw.searchQueries
   };
 }
-function buildPrompt3(keyword, location) {
+function buildPrompt3(query, location) {
   const locationContext = location ? ` The user is searching from ${location.city}, ${location.region}, ${location.country}.` : "";
-  return `Based on your training knowledge, what websites, services, or organizations are commonly associated with "${keyword}"?${locationContext} List the most relevant ones and include their domain names (e.g. example.com) where you know them.`;
+  return `Based on your training knowledge, what websites, services, or organizations are commonly associated with "${query}"?${locationContext} List the most relevant ones and include their domain names (e.g. example.com) where you know them.`;
 }
 function extractAnswerText2(rawResponse) {
   try {
@@ -15942,7 +16193,7 @@ var localAdapter = {
   },
   async executeTrackedQuery(input, config) {
     const raw = await executeTrackedQuery4({
-      keyword: input.keyword,
+      query: input.query,
       canonicalDomains: input.canonicalDomains,
       competitorDomains: input.competitorDomains,
       config: toLocalConfig(config),
@@ -16160,7 +16411,7 @@ var chatgptTarget = {
   baseUrl: "https://chatgpt.com",
   newConversationUrl: "https://chatgpt.com/?model=auto",
   responseSelector: '[data-testid="conversation-turn-3"], article:last-of-type, .agent-turn:last-of-type',
-  async submitQuery(client, keyword) {
+  async submitQuery(client, query) {
     const inputReady = await waitForElement(
       client,
       '#prompt-textarea, [contenteditable="true"][data-placeholder]',
@@ -16177,7 +16428,7 @@ var chatgptTarget = {
       expression: `(document.querySelector('#prompt-textarea') || document.querySelector('[contenteditable="true"][data-placeholder]')).focus()`
     });
     await sleep2(200);
-    for (const char of keyword) {
+    for (const char of query) {
       await client.Input.dispatchKeyEvent({
         type: "keyDown",
         key: char,
@@ -16503,7 +16754,7 @@ var cdpChatgptAdapter = {
     const target = chatgptTarget;
     try {
       const client = await conn.prepareForQuery(target);
-      await target.submitQuery(client, input.keyword);
+      await target.submitQuery(client, input.query);
       await target.waitForResponse(client);
       const answerText = await target.extractAnswer(client);
       const groundingSources = await target.extractCitations(client);
@@ -16528,7 +16779,7 @@ var cdpChatgptAdapter = {
         },
         model: "chatgpt-web",
         groundingSources,
-        searchQueries: [input.keyword],
+        searchQueries: [input.query],
         screenshotPath: capturedScreenshotPath
       };
     } catch (err) {
@@ -16627,7 +16878,7 @@ async function healthcheck5(config) {
 async function executeTrackedQuery5(input) {
   const model = input.config.model ?? DEFAULT_MODEL5;
   const client = new OpenAI3({ apiKey: input.config.apiKey, baseURL: BASE_URL });
-  const prompt = buildPrompt4(input.keyword, input.location);
+  const prompt = buildPrompt4(input.query, input.location);
   try {
     const response = await withRetry5(
       () => client.chat.completions.create({
@@ -16684,11 +16935,11 @@ function reparseStoredResult4(rawResponse) {
     searchQueries: []
   };
 }
-function buildPrompt4(keyword, location) {
+function buildPrompt4(query, location) {
   if (location) {
-    return `${keyword} (searching from ${location.city}, ${location.region}, ${location.country})`;
+    return `${query} (searching from ${location.city}, ${location.region}, ${location.country})`;
   }
-  return keyword;
+  return query;
 }
 function extractCitations(rawResponse) {
   if (Array.isArray(rawResponse.citations)) {
@@ -16851,7 +17102,7 @@ var perplexityAdapter = {
   },
   async executeTrackedQuery(input, config) {
     const raw = await executeTrackedQuery5({
-      keyword: input.keyword,
+      query: input.query,
       canonicalDomains: input.canonicalDomains,
       competitorDomains: input.competitorDomains,
       config: toPerplexityConfig(config),
@@ -17318,7 +17569,7 @@ var JobRunner = class {
     const startTime = Date.now();
     let runLocation;
     let activeProviders = [];
-    let projectKeywords = [];
+    let projectQueries = [];
     const providerDispatchCounts = /* @__PURE__ */ new Map();
     try {
       const existingRun = this.getRunState(runId);
@@ -17329,7 +17580,7 @@ var JobRunner = class {
         this.handleCancelledRun(runId, projectId, startTime, {
           providerCount: 0,
           providers: [],
-          keywordCount: 0
+          queryCount: 0
         });
         return;
       }
@@ -17360,7 +17611,7 @@ var JobRunner = class {
         throw new Error("No providers configured. Add at least one provider API key.");
       }
       log.info("run.dispatch", { runId, providerCount: activeProviders.length, providers: activeProviders.map((p) => p.adapter.name) });
-      projectKeywords = this.db.select().from(keywords).where(eq23(keywords.projectId, projectId)).all();
+      projectQueries = this.db.select().from(queries).where(eq23(queries.projectId, projectId)).all();
       const projectCompetitors = this.db.select().from(competitors).where(eq23(competitors.projectId, projectId)).all();
       const competitorDomains = projectCompetitors.map((c) => c.domain);
       const allDomains = effectiveDomains({
@@ -17370,10 +17621,10 @@ var JobRunner = class {
       const executionContext = {
         providerCount: activeProviders.length,
         providers: activeProviders.map((provider) => provider.adapter.name),
-        keywordCount: projectKeywords.length,
+        queryCount: projectQueries.length,
         ...runLocation ? { location: runLocation.label } : {}
       };
-      const queriesPerProvider = projectKeywords.length;
+      const queriesPerProvider = projectQueries.length;
       const todayPeriod = getCurrentUsageDay();
       for (const p of activeProviders) {
         const providerScope = `${projectId}:${p.adapter.name}`;
@@ -17399,7 +17650,7 @@ var JobRunner = class {
       let totalSnapshotsInserted = 0;
       const apiProviders = activeProviders.filter((p) => !isBrowserProvider(p.adapter.name));
       const browserProviders = activeProviders.filter((p) => isBrowserProvider(p.adapter.name));
-      const processKeywordForProvider = async (registeredProvider, kw) => {
+      const processQueryForProvider = async (registeredProvider, q) => {
         const { adapter, config } = registeredProvider;
         const providerName = adapter.name;
         const gate = executionGates.get(providerName);
@@ -17412,7 +17663,7 @@ var JobRunner = class {
             providerDispatchCounts.set(providerName, (providerDispatchCounts.get(providerName) ?? 0) + 1);
             const raw = await adapter.executeTrackedQuery(
               {
-                keyword: kw.keyword,
+                query: q.query,
                 canonicalDomains: allDomains,
                 competitorDomains,
                 location: runLocation
@@ -17421,7 +17672,7 @@ var JobRunner = class {
             );
             this.throwIfRunCancelled(runId);
             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 });
+            log.info("query.result", { runId, provider: providerName, query: q.query, citedDomains: normalized.citedDomains, groundingSources: normalized.groundingSources.map((s) => s.uri), matchDomains: allDomains });
             const citationState = determineCitationState(normalized, allDomains);
             const answerMentioned = determineAnswerMentioned(
               normalized.answerText,
@@ -17446,7 +17697,7 @@ var JobRunner = class {
               this.db.insert(querySnapshots).values({
                 id: snapshotId,
                 runId,
-                keywordId: kw.id,
+                queryId: q.id,
                 provider: providerName,
                 model: raw.model,
                 citationState,
@@ -17469,7 +17720,7 @@ var JobRunner = class {
               this.db.insert(querySnapshots).values({
                 id: crypto19.randomUUID(),
                 runId,
-                keywordId: kw.id,
+                queryId: q.id,
                 provider: providerName,
                 model: raw.model,
                 citationState,
@@ -17489,7 +17740,7 @@ var JobRunner = class {
               }).run();
             }
             totalSnapshotsInserted++;
-            log.info("query.citation", { runId, provider: providerName, keyword: kw.keyword, citationState, answerMentioned });
+            log.info("query.citation", { runId, provider: providerName, query: q.query, citationState, answerMentioned });
           });
         } catch (err) {
           if (err instanceof RunCancelledError) {
@@ -17497,20 +17748,20 @@ var JobRunner = class {
           }
           const msg = err instanceof Error ? err.message : String(err);
           const stack = err instanceof Error ? err.stack : void 0;
-          log.error("query.failed", { runId, provider: providerName, keyword: kw.keyword, error: msg, stack });
+          log.error("query.failed", { runId, provider: providerName, query: q.query, error: msg, stack });
           if (!providerErrors.has(providerName)) {
             providerErrors.set(providerName, msg);
           }
         }
       };
       await runWithConcurrency(apiProviders, resolveProviderFanout(), async (registeredProvider) => {
-        await Promise.all(projectKeywords.map(async (kw) => {
-          await processKeywordForProvider(registeredProvider, kw);
+        await Promise.all(projectQueries.map(async (q) => {
+          await processQueryForProvider(registeredProvider, q);
         }));
       });
       for (const registeredProvider of browserProviders) {
-        for (const kw of projectKeywords) {
-          await processKeywordForProvider(registeredProvider, kw);
+        for (const q of projectQueries) {
+          await processQueryForProvider(registeredProvider, q);
         }
       }
       this.throwIfRunCancelled(runId);
@@ -17531,7 +17782,7 @@ var JobRunner = class {
         status: finalStatus,
         providerCount: executionContext.providerCount,
         providers: executionContext.providers,
-        keywordCount: executionContext.keywordCount,
+        queryCount: executionContext.queryCount,
         durationMs: Date.now() - startTime,
         ...executionContext.location ? { location: executionContext.location } : {}
       });
@@ -17545,7 +17796,7 @@ var JobRunner = class {
       const executionContext = {
         providerCount: activeProviders.length,
         providers: activeProviders.map((provider) => provider.adapter.name),
-        keywordCount: projectKeywords.length,
+        queryCount: projectQueries.length,
         ...runLocation ? { location: runLocation.label } : {}
       };
       if (err instanceof RunCancelledError || this.isRunCancelled(runId)) {
@@ -17564,7 +17815,7 @@ var JobRunner = class {
         status: "failed",
         providerCount: executionContext.providerCount,
         providers: executionContext.providers,
-        keywordCount: executionContext.keywordCount,
+        queryCount: executionContext.queryCount,
         durationMs: Date.now() - startTime,
         ...executionContext.location ? { location: executionContext.location } : {}
       });
@@ -17623,7 +17874,7 @@ var JobRunner = class {
       status: "cancelled",
       providerCount: context.providerCount,
       providers: context.providers,
-      keywordCount: context.keywordCount,
+      queryCount: context.queryCount,
       durationMs: Date.now() - startTime,
       ...context.location ? { location: context.location } : {}
     });
@@ -18819,7 +19070,7 @@ var Notifier = class {
             type: i.type,
             severity: i.severity,
             title: i.title,
-            keyword: i.keyword,
+            query: i.query,
             provider: i.provider
           })),
           dashboardUrl: `${this.serverUrl}/projects/${project.name}`
@@ -18840,27 +19091,27 @@ var Notifier = class {
     const previousRunId = recentRuns[1].id;
     if (currentRunId !== runId) return [];
     const currentSnapshots = this.db.select({
-      keywordId: querySnapshots.keywordId,
-      keyword: keywords.keyword,
+      queryId: querySnapshots.queryId,
+      query: queries.query,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(keywords, eq30(querySnapshots.keywordId, keywords.id)).where(eq30(querySnapshots.runId, currentRunId)).all();
+    }).from(querySnapshots).leftJoin(queries, eq30(querySnapshots.queryId, queries.id)).where(eq30(querySnapshots.runId, currentRunId)).all();
     const previousSnapshots = this.db.select({
-      keywordId: querySnapshots.keywordId,
+      queryId: querySnapshots.queryId,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState
     }).from(querySnapshots).where(eq30(querySnapshots.runId, previousRunId)).all();
     const prevMap = /* @__PURE__ */ new Map();
     for (const s of previousSnapshots) {
-      prevMap.set(`${s.keywordId}:${s.provider}`, s.citationState);
+      prevMap.set(`${s.queryId}:${s.provider}`, s.citationState);
     }
     const transitions = [];
     for (const s of currentSnapshots) {
-      const key = `${s.keywordId}:${s.provider}`;
+      const key = `${s.queryId}:${s.provider}`;
       const prevState = prevMap.get(key);
       if (prevState && prevState !== s.citationState) {
         transitions.push({
-          keyword: s.keyword ?? s.keywordId,
+          query: s.query ?? s.queryId,
           from: prevState,
           to: s.citationState,
           provider: s.provider
@@ -20330,7 +20581,7 @@ var SnapshotService = class {
   async createReport(input) {
     const companyName = input.companyName.trim();
     const domain = normalizeDomain3(input.domain);
-    const manualPhrases = normalizeStringList(input.phrases ?? []);
+    const manualQueries = normalizeStringList(resolveSnapshotRequestQueries(input));
     const manualCompetitors = normalizeStringList(input.competitors ?? []);
     const providers = this.registry.getAll();
     if (providers.length === 0) {
@@ -20342,9 +20593,9 @@ var SnapshotService = class {
       fetchSiteText(domain),
       this.runAudit(homepageUrl)
     ]);
-    if (manualPhrases.length === 0 && !siteText) {
+    if (manualQueries.length === 0 && !siteText) {
       throw new Error(
-        `Could not analyze https://${extractHostname2(domain)}. Try again with a reachable homepage or pass manual category queries via --phrases.`
+        `Could not analyze https://${extractHostname2(domain)}. Try again with a reachable homepage or pass manual category queries via --queries.`
       );
     }
     const profile = await this.buildProfile({
@@ -20352,13 +20603,13 @@ var SnapshotService = class {
       domain,
       siteText,
       audit,
-      manualPhrases,
+      manualQueries,
       analysisProvider
     });
     const queryResults = await this.runSnapshotQueries({
       companyName,
       domain,
-      phrases: profile.phrases,
+      queries: profile.queries,
       providers,
       manualCompetitors
     });
@@ -20372,7 +20623,7 @@ var SnapshotService = class {
       analysisProvider
     });
     const enrichedResults = applyBatchAssessment(queryResults, batchAssessment);
-    const summary = buildSnapshotSummary(companyName, profile.phrases, providers, enrichedResults, audit, batchAssessment);
+    const summary = buildSnapshotSummary(companyName, profile.queries, providers, enrichedResults, audit, batchAssessment);
     const reportCompetitors = uniqueStrings([
       ...manualCompetitors,
       ...summary.topCompetitors.map((entry) => entry.name)
@@ -20382,7 +20633,7 @@ var SnapshotService = class {
       domain,
       homepageUrl,
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      phrases: profile.phrases,
+      queries: profile.queries,
       competitors: reportCompetitors,
       profile: {
         industry: profile.industry,
@@ -20419,16 +20670,16 @@ var SnapshotService = class {
       try {
         const raw = await ctx.analysisProvider.adapter.generateText(prompt, ctx.analysisProvider.config);
         const parsed = parseJsonObject(raw);
-        const parsedPhrases = ctx.manualPhrases.length > 0 ? ctx.manualPhrases : normalizeStringList(parsed.phrases ?? []).slice(0, SNAPSHOT_QUERY_COUNT);
-        if (ctx.manualPhrases.length === 0 && parsedPhrases.length === 0) {
-          throw new Error("no phrases returned");
+        const parsedQueries = ctx.manualQueries.length > 0 ? ctx.manualQueries : normalizeStringList(parsed.queries ?? []).slice(0, SNAPSHOT_QUERY_COUNT);
+        if (ctx.manualQueries.length === 0 && parsedQueries.length === 0) {
+          throw new Error("no queries returned");
         }
         return {
           industry: parsed.industry?.trim() || "Unknown",
           summary: parsed.summary?.trim() || ctx.audit.summary,
           services: uniqueStrings(parsed.services ?? []).slice(0, 6),
           categoryTerms: uniqueStrings(parsed.categoryTerms ?? []).slice(0, 8),
-          phrases: parsedPhrases
+          queries: parsedQueries
         };
       } catch (err) {
         log12.warn("profile.generation-failed", {
@@ -20438,9 +20689,9 @@ var SnapshotService = class {
         });
       }
     }
-    if (ctx.manualPhrases.length === 0) {
+    if (ctx.manualQueries.length === 0) {
       throw new Error(
-        "Automatic category-query generation requires a configured API provider. Add OpenAI, Claude, Gemini, Perplexity, or Local, or pass --phrases manually."
+        "Automatic category-query generation requires a configured API provider. Add OpenAI, Claude, Gemini, Perplexity, or Local, or pass --queries manually."
       );
     }
     return {
@@ -20448,7 +20699,7 @@ var SnapshotService = class {
       summary: ctx.audit.summary,
       services: [],
       categoryTerms: [],
-      phrases: ctx.manualPhrases
+      queries: ctx.manualQueries
     };
   }
   async runSnapshotQueries(ctx) {
@@ -20463,15 +20714,15 @@ var SnapshotService = class {
       );
     }
     const competitorDomains = ctx.manualCompetitors.filter(isDomainLike);
-    return Promise.all(ctx.phrases.map(async (phrase) => ({
-      phrase,
+    return Promise.all(ctx.queries.map(async (query) => ({
+      query,
       providerResults: await Promise.all(ctx.providers.map(async (provider) => {
         const gate = gates.get(provider.adapter.name);
         return gate.run(async () => {
           try {
             const raw = await provider.adapter.executeTrackedQuery(
               {
-                keyword: phrase,
+                query,
                 canonicalDomains: [ctx.domain],
                 competitorDomains
               },
@@ -20528,8 +20779,8 @@ var SnapshotService = class {
       return buildFallbackBatchAssessment(ctx.companyName, ctx.audit);
     }
     const responses = ctx.queryResults.flatMap(
-      (query) => query.providerResults.filter((result) => !result.error).map((result) => ({
-        phrase: query.phrase,
+      (queryResult) => queryResult.providerResults.filter((result) => !result.error).map((result) => ({
+        query: queryResult.query,
         provider: result.provider,
         displayName: result.displayName,
         heuristicMentioned: result.mentioned,
@@ -20555,10 +20806,10 @@ var SnapshotService = class {
       const raw = await ctx.analysisProvider.adapter.generateText(prompt, ctx.analysisProvider.config);
       const parsed = parseJsonObject(raw);
       return {
-        assessments: (parsed.assessments ?? []).filter((assessment) => assessment.phrase && assessment.provider).map((assessment) => {
+        assessments: (parsed.assessments ?? []).filter((assessment) => assessment.query && assessment.provider).map((assessment) => {
           const hasReviewedCompetitors = assessment.recommendedCompetitors !== void 0;
           return {
-            phrase: assessment.phrase,
+            query: assessment.query,
             provider: assessment.provider,
             mentioned: assessment.mentioned,
             describedAccurately: assessment.describedAccurately,
@@ -20594,11 +20845,11 @@ function buildProfilePrompt(ctx) {
     "Use ONLY the homepage text below. Do not browse or invent facts.",
     "Infer the company category, summarize what it sells, and generate non-branded category queries buyers would ask an AI assistant.",
     'Never produce brand queries like "what does Acme do?"',
-    `Return strict JSON with keys: industry, summary, services, categoryTerms, phrases.`,
-    `phrases must contain exactly ${SNAPSHOT_QUERY_COUNT} buyer-style category/recommendation queries unless manual phrases are provided.`
+    `Return strict JSON with keys: industry, summary, services, categoryTerms, queries.`,
+    `queries must contain exactly ${SNAPSHOT_QUERY_COUNT} buyer-style category/recommendation queries unless manual queries are provided.`
   ];
-  if (ctx.manualPhrases.length > 0) {
-    instructions.push('Manual phrases were already supplied. Echo them back unchanged in the "phrases" array.');
+  if (ctx.manualQueries.length > 0) {
+    instructions.push('Manual queries were already supplied. Echo them back unchanged in the "queries" array.');
   }
   return [
     ...instructions,
@@ -20616,7 +20867,7 @@ function buildBatchAnalysisPrompt(ctx) {
     "You are reviewing AI answer-engine responses for a sales-facing AEO snapshot report.",
     "Use ONLY the provided facts and responses. Do not invent companies or claims.",
     "Return strict JSON with keys: assessments, whatThisMeans, recommendedActions.",
-    "Each assessment must include: phrase, provider, mentioned, describedAccurately, accuracyNotes, incorrectClaims, recommendedCompetitors.",
+    "Each assessment must include: query, provider, mentioned, describedAccurately, accuracyNotes, incorrectClaims, recommendedCompetitors.",
     "describedAccurately must be one of: yes, no, unknown, not-mentioned.",
     "",
     "CRITICAL \u2014 recommendedCompetitors extraction:",
@@ -20652,12 +20903,12 @@ function buildFallbackBatchAssessment(companyName, audit) {
 function applyBatchAssessment(queryResults, batchAssessment) {
   const assessmentMap = /* @__PURE__ */ new Map();
   for (const assessment of batchAssessment.assessments) {
-    assessmentMap.set(`${assessment.phrase}::${assessment.provider}`, assessment);
+    assessmentMap.set(`${assessment.query}::${assessment.provider}`, assessment);
   }
-  return queryResults.map((query) => ({
-    phrase: query.phrase,
-    providerResults: query.providerResults.map((result) => {
-      const assessment = assessmentMap.get(`${query.phrase}::${result.provider}`);
+  return queryResults.map((queryResult) => ({
+    query: queryResult.query,
+    providerResults: queryResult.providerResults.map((result) => {
+      const assessment = assessmentMap.get(`${queryResult.query}::${result.provider}`);
       if (!assessment) {
         return {
           ...result,
@@ -20680,8 +20931,8 @@ function applyBatchAssessment(queryResults, batchAssessment) {
     })
   }));
 }
-function buildSnapshotSummary(companyName, phrases, providers, queryResults, audit, batchAssessment) {
-  const allResults = queryResults.flatMap((query) => query.providerResults);
+function buildSnapshotSummary(companyName, queries2, providers, queryResults, audit, batchAssessment) {
+  const allResults = queryResults.flatMap((queryResult) => queryResult.providerResults);
   const successfulResults = allResults.filter((result) => !result.error);
   const failedComparisons = allResults.length - successfulResults.length;
   const mentionCount = successfulResults.filter((result) => result.mentioned).length;
@@ -20694,7 +20945,7 @@ function buildSnapshotSummary(companyName, phrases, providers, queryResults, aud
     }
   }
   const topCompetitors = [...competitorCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 10).map(([name, count]) => ({ name, count }));
-  const defaultMeaning = totalComparisons > 0 ? `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider-query response${totalComparisons === 1 ? "" : "s"} across ${phrases.length} category queries.` : `No successful provider responses were returned across ${phrases.length} category queries.`;
+  const defaultMeaning = totalComparisons > 0 ? `${companyName} was mentioned in ${mentionCount}/${totalComparisons} successful provider-query response${totalComparisons === 1 ? "" : "s"} across ${queries2.length} category queries.` : `No successful provider responses were returned across ${queries2.length} category queries.`;
   const failureNote = failedComparisons > 0 ? [
     `${failedComparisons} provider response${failedComparisons === 1 ? "" : "s"} failed and ${failedComparisons === 1 ? "was" : "were"} excluded from visibility totals.`
   ] : [];
@@ -20704,7 +20955,7 @@ function buildSnapshotSummary(companyName, phrases, providers, queryResults, aud
   const combinedWhatThisMeans = uniqueStrings([...whatThisMeans, ...failureNote]).slice(0, 5);
   const recommendedActions = batchAssessment.recommendedActions.length > 0 ? batchAssessment.recommendedActions : buildFallbackRecommendedActions(audit);
   return {
-    totalQueries: phrases.length,
+    totalQueries: queries2.length,
     totalProviders: providers.length,
     totalComparisons,
     mentionCount,
@@ -20712,7 +20963,7 @@ function buildSnapshotSummary(companyName, phrases, providers, queryResults, aud
     topCompetitors,
     visibilityGap: buildVisibilityGap(
       companyName,
-      phrases.length,
+      queries2.length,
       providers.length,
       totalComparisons,
       mentionCount,
@@ -21646,7 +21897,7 @@ async function createServer(opts) {
       const conn = registry.get("cdp:chatgpt");
       if (!conn) throw new Error("CDP provider not configured");
       const result = await conn.adapter.executeTrackedQuery(
-        { keyword: query, canonicalDomains: [], competitorDomains: [] },
+        { query, canonicalDomains: [], competitorDomains: [] },
         conn.config
       );
       const raw = result.rawResponse;
@@ -21657,21 +21908,21 @@ async function createServer(opts) {
         citations: raw.groundingSources ?? []
       }];
     },
-    onGenerateKeywords: async (providerName, count, project) => {
+    onGenerateQueries: async (providerName, count, project) => {
       const provider = registry.get(providerName);
       if (!provider) throw new Error(`Provider "${providerName}" is not configured`);
       const siteText = await fetchSiteText(project.domain);
-      const prompt = buildKeywordGenerationPrompt({
+      const prompt = buildQueryGenerationPrompt({
         domain: project.domain,
         displayName: project.displayName,
         country: project.country,
         language: project.language,
-        existingKeywords: project.existingKeywords,
+        existingQueries: project.existingQueries,
         siteText,
         count
       });
       const raw = await provider.adapter.generateText(prompt, provider.config);
-      return parseKeywordResponse(raw, count);
+      return parseQueryResponse(raw, count);
     },
     onSnapshotRequested: async (input) => {
       return snapshotService.createReport(input);
@@ -21742,7 +21993,7 @@ async function createServer(opts) {
   });
   return app;
 }
-function buildKeywordGenerationPrompt(ctx) {
+function buildQueryGenerationPrompt(ctx) {
   const lines = [
     "You are an SEO and AEO (Answer Engine Optimization) expert. Given a website's content, generate search queries that potential users would type into AI answer engines (ChatGPT, Gemini, Claude) to find services, products, or information like what this site offers.",
     "",
@@ -21754,23 +22005,23 @@ function buildKeywordGenerationPrompt(ctx) {
   if (ctx.siteText) {
     lines.push("", "--- Site Content ---", ctx.siteText, "--- End Site Content ---");
   }
-  if (ctx.existingKeywords.length > 0) {
-    lines.push("", `Already tracking (do NOT duplicate): ${ctx.existingKeywords.join(", ")}`);
+  if (ctx.existingQueries.length > 0) {
+    lines.push("", `Already tracking (do NOT duplicate): ${ctx.existingQueries.join(", ")}`);
   }
   lines.push(
     "",
-    `Generate exactly ${ctx.count} key phrases that:`,
+    `Generate exactly ${ctx.count} queries that:`,
     '- Are short and concise (2-5 words each, like "best dentist brooklyn" not "what is the best dentist office in the brooklyn area for families")',
     "- Are natural phrases people would type into AI answer engines",
     "- Cover different intents (informational, transactional, navigational)",
     `- Are relevant to the ${ctx.country} market in ${ctx.language}`,
     "- Reflect the actual services/products/content found on the site",
     "",
-    "Return ONLY the key phrases, one per line, no numbering or bullets."
+    "Return ONLY the queries, one per line, no numbering or bullets."
   );
   return lines.join("\n");
 }
-function parseKeywordResponse(raw, count) {
+function parseQueryResponse(raw, count) {
   const seen = /* @__PURE__ */ new Set();
   const results = [];
   for (const line of raw.split("\n")) {