@ainyc/canonry 1.20.1 → 1.21.1

package/dist/{chunk-YXYC7NGJ.js → chunk-2JBQ7NMO.js}

@@ -35,7 +35,7 @@ function loadConfig() {
     throw new Error(
       `Config not found at ${configPath}.
 Run "canonry init" to set up interactively, or "canonry init --gemini-key <key>" for non-interactive setup.
-For CI/Docker, use "canonry bootstrap" with env vars (GEMINI_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET).`
+For CI/Docker, use "canonry bootstrap" with env vars (GEMINI_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, PERPLEXITY_API_KEY, GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET).`
     );
   }
   const raw = fs.readFileSync(configPath, "utf-8");
@@ -72,6 +72,16 @@ Do not write config.yaml by hand; use "canonry init", "canonry settings", or "ca
     } catch {
     }
   }
+  if (parsed.basePath) {
+    const normalizedBase = "/" + parsed.basePath.replace(/^\/|\/$/g, "");
+    try {
+      const url = new URL(parsed.apiUrl);
+      if (normalizedBase !== "/" && !url.pathname.startsWith(normalizedBase)) {
+        parsed.apiUrl = url.origin + normalizedBase;
+      }
+    } catch {
+    }
+  }
   return parsed;
 }
 function saveConfig(config) {
@@ -167,7 +177,7 @@ import { fileURLToPath } from "url";
 import Fastify from "fastify";
 
 // ../contracts/src/config-schema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../contracts/src/provider.ts
 import { z } from "zod";
@@ -176,30 +186,18 @@ var providerQuotaPolicySchema = z.object({
   maxRequestsPerMinute: z.number().int().positive(),
   maxRequestsPerDay: z.number().int().positive()
 });
-var PROVIDER_NAMES = ["gemini", "openai", "claude", "local", "cdp:chatgpt"];
-var providerNameSchema = z.enum(PROVIDER_NAMES);
-var PROVIDER_MODE = {
-  gemini: "api",
-  openai: "api",
-  claude: "api",
-  local: "api",
-  "cdp:chatgpt": "browser"
-};
+var providerNameSchema = z.string().min(1);
+var apiProviderNameSchema = z.string().min(1);
 function isBrowserProvider(name) {
-  return PROVIDER_MODE[name] === "browser";
+  return name.startsWith("cdp:");
 }
 var CDP_TARGETS = ["cdp:chatgpt"];
-function parseProviderName(input) {
-  const lower = input.trim().toLowerCase();
-  return PROVIDER_NAMES.includes(lower) ? lower : void 0;
-}
 function resolveProviderInput(input) {
   const lower = input.trim().toLowerCase();
   if (lower === "cdp") {
     return [...CDP_TARGETS];
   }
-  const parsed = parseProviderName(lower);
-  return parsed ? [parsed] : [];
+  return lower ? [lower] : [];
 }
 var locationContextSchema = z.object({
   label: z.string().min(1),
@@ -229,118 +227,148 @@ var notificationDtoSchema = z2.object({
   updatedAt: z2.string()
 });
 
+// ../contracts/src/project.ts
+import { z as z3 } from "zod";
+var configSourceSchema = z3.enum(["cli", "api", "config-file"]);
+function findDuplicateLocationLabels(locations) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const location of locations) {
+    if (seen.has(location.label)) {
+      duplicates.add(location.label);
+      continue;
+    }
+    seen.add(location.label);
+  }
+  return [...duplicates];
+}
+function hasLocationLabel(locations, label) {
+  if (!label) return true;
+  return locations.some((location) => location.label === label);
+}
+var projectUpsertRequestSchema = z3.object({
+  displayName: z3.string().min(1),
+  canonicalDomain: z3.string().min(1),
+  ownedDomains: z3.array(z3.string().min(1)).optional(),
+  country: z3.string().length(2),
+  language: z3.string().min(2),
+  tags: z3.array(z3.string()).optional(),
+  labels: z3.record(z3.string(), z3.string()).optional(),
+  providers: z3.array(providerNameSchema).optional(),
+  locations: z3.array(locationContextSchema).optional(),
+  defaultLocation: z3.string().nullable().optional(),
+  configSource: configSourceSchema.optional()
+});
+var projectDtoSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  displayName: z3.string().optional(),
+  canonicalDomain: z3.string(),
+  ownedDomains: z3.array(z3.string()).default([]),
+  country: z3.string().length(2),
+  language: z3.string().min(2),
+  tags: z3.array(z3.string()).default([]),
+  labels: z3.record(z3.string(), z3.string()).default({}),
+  locations: z3.array(locationContextSchema).default([]),
+  defaultLocation: z3.string().nullable().optional(),
+  configSource: configSourceSchema.default("cli"),
+  configRevision: z3.number().int().positive().default(1),
+  createdAt: z3.string().optional(),
+  updatedAt: z3.string().optional()
+});
+function normalizeProjectDomain(input) {
+  let domain = input.trim().toLowerCase();
+  try {
+    if (domain.includes("://")) {
+      domain = new URL(domain).hostname.toLowerCase();
+    }
+  } catch {
+  }
+  return domain.replace(/^www\./, "");
+}
+function effectiveDomains(project) {
+  const all = [project.canonicalDomain, ...project.ownedDomains ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const d of all) {
+    const trimmed = d.trim();
+    if (!trimmed) continue;
+    const norm = normalizeProjectDomain(trimmed);
+    if (seen.has(norm)) continue;
+    seen.add(norm);
+    result.push(trimmed);
+  }
+  return result;
+}
+
 // ../contracts/src/config-schema.ts
-var configMetadataSchema = z3.object({
-  name: z3.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, {
+var configMetadataSchema = z4.object({
+  name: z4.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, {
     message: "Name must be a lowercase slug (letters, numbers, hyphens)"
   }),
-  labels: z3.record(z3.string(), z3.string()).optional().default({})
+  labels: z4.record(z4.string(), z4.string()).optional().default({})
 });
-var configScheduleSchema = z3.object({
-  preset: z3.string().optional(),
-  cron: z3.string().optional(),
-  timezone: z3.string().optional().default("UTC"),
-  providers: z3.array(providerNameSchema).optional().default([])
+var configScheduleSchema = z4.object({
+  preset: z4.string().optional(),
+  cron: z4.string().optional(),
+  timezone: z4.string().optional().default("UTC"),
+  providers: z4.array(providerNameSchema).optional().default([])
 }).refine(
   (data) => data.preset && !data.cron || !data.preset && data.cron,
   { message: 'Exactly one of "preset" or "cron" must be provided' }
 ).optional();
-var configNotificationSchema = z3.object({
-  channel: z3.literal("webhook"),
-  url: z3.string().url(),
-  events: z3.array(notificationEventSchema).min(1)
+var configNotificationSchema = z4.object({
+  channel: z4.literal("webhook"),
+  url: z4.string().url(),
+  events: z4.array(notificationEventSchema).min(1)
 });
-var configGoogleSchema = z3.object({
-  gsc: z3.object({
-    propertyUrl: z3.string()
+var configGoogleSchema = z4.object({
+  gsc: z4.object({
+    propertyUrl: z4.string()
   }).optional(),
-  syncSchedule: z3.object({
-    preset: z3.string().optional(),
-    cron: z3.string().optional()
+  syncSchedule: z4.object({
+    preset: z4.string().optional(),
+    cron: z4.string().optional()
   }).optional()
 }).optional();
-var configSpecSchema = z3.object({
-  displayName: z3.string().min(1),
-  canonicalDomain: z3.string().min(1),
-  ownedDomains: z3.array(z3.string().min(1)).optional().default([]),
-  country: z3.string().length(2),
-  language: z3.string().min(2),
-  keywords: z3.array(z3.string().min(1)).optional().default([]),
-  competitors: z3.array(z3.string().min(1)).optional().default([]),
-  providers: z3.array(providerNameSchema).optional().default([]),
-  locations: z3.array(locationContextSchema).optional().default([]),
-  defaultLocation: z3.string().optional(),
+var configSpecSchema = z4.object({
+  displayName: z4.string().min(1),
+  canonicalDomain: z4.string().min(1),
+  ownedDomains: z4.array(z4.string().min(1)).optional().default([]),
+  country: z4.string().length(2),
+  language: z4.string().min(2),
+  keywords: z4.array(z4.string().min(1)).optional().default([]),
+  competitors: z4.array(z4.string().min(1)).optional().default([]),
+  providers: z4.array(providerNameSchema).optional().default([]),
+  locations: z4.array(locationContextSchema).optional().default([]),
+  defaultLocation: z4.string().optional(),
   schedule: configScheduleSchema,
-  notifications: z3.array(configNotificationSchema).optional().default([]),
+  notifications: z4.array(configNotificationSchema).optional().default([]),
   google: configGoogleSchema
+}).superRefine((spec, ctx) => {
+  const duplicateLabels = findDuplicateLocationLabels(spec.locations);
+  if (duplicateLabels.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`,
+      path: ["locations"]
+    });
+  }
+  if (!hasLocationLabel(spec.locations, spec.defaultLocation)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `defaultLocation "${spec.defaultLocation}" must match a configured location label`,
+      path: ["defaultLocation"]
+    });
+  }
 });
-var projectConfigSchema = z3.object({
-  apiVersion: z3.literal("canonry/v1"),
-  kind: z3.literal("Project"),
+var projectConfigSchema = z4.object({
+  apiVersion: z4.literal("canonry/v1"),
+  kind: z4.literal("Project"),
   metadata: configMetadataSchema,
   spec: configSpecSchema
 });
 
-// ../contracts/src/models.ts
-var MODEL_REGISTRY = {
-  gemini: {
-    defaultModel: "gemini-3-flash",
-    validationPattern: /^gemini-/,
-    validationHint: 'model name must start with "gemini-" (e.g. gemini-3-flash)',
-    knownModels: [
-      { id: "gemini-3.1-pro-preview", displayName: "Gemini 3.1 Pro (Preview)", tier: "flagship" },
-      { id: "gemini-3-flash-preview", displayName: "Gemini 3 Flash (Preview)", tier: "standard" },
-      { id: "gemini-3.1-flash-lite-preview", displayName: "Gemini 3.1 Flash-Lite (Preview)", tier: "economy" },
-      { id: "gemini-2.5-flash", displayName: "Gemini 2.5 Flash", tier: "standard" }
-    ]
-  },
-  openai: {
-    defaultModel: "gpt-5.4",
-    validationPattern: /^(gpt-|o\d)/,
-    validationHint: "expected a GPT or o-series model name (e.g. gpt-5.4, o3)",
-    knownModels: [
-      { id: "gpt-5.4", displayName: "GPT-5.4", tier: "flagship" },
-      { id: "gpt-5.4-pro", displayName: "GPT-5.4 Pro", tier: "flagship" },
-      { id: "gpt-5-mini", displayName: "GPT-5 Mini", tier: "fast" },
-      { id: "gpt-5-nano", displayName: "GPT-5 Nano", tier: "economy" },
-      { id: "gpt-5", displayName: "GPT-5", tier: "standard" },
-      { id: "gpt-4.1", displayName: "GPT-4.1", tier: "standard" }
-    ]
-  },
-  claude: {
-    defaultModel: "claude-sonnet-4-6",
-    validationPattern: /^claude-/,
-    validationHint: 'model name must start with "claude-" (e.g. claude-sonnet-4-6)',
-    knownModels: [
-      { id: "claude-opus-4-6", displayName: "Claude Opus 4.6", tier: "flagship" },
-      { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6", tier: "standard" },
-      { id: "claude-haiku-4-5", displayName: "Claude Haiku 4.5", tier: "fast" }
-    ]
-  },
-  local: {
-    defaultModel: "llama3",
-    validationPattern: /./,
-    validationHint: "any model name accepted",
-    knownModels: [
-      { id: "llama3", displayName: "Llama 3", tier: "standard" }
-    ]
-  },
-  "cdp:chatgpt": {
-    defaultModel: "chatgpt-web",
-    validationPattern: /./,
-    validationHint: "model is detected from the ChatGPT web UI",
-    knownModels: [
-      { id: "chatgpt-web", displayName: "ChatGPT (Web UI)", tier: "standard" }
-    ]
-  }
-};
-function getDefaultModel(provider) {
-  return MODEL_REGISTRY[provider].defaultModel;
-}
-function isValidModelName(provider, model) {
-  return MODEL_REGISTRY[provider].validationPattern.test(model);
-}
-
 // ../contracts/src/errors.ts
 var AppError = class extends Error {
   code;
@@ -384,177 +412,135 @@ function runNotCancellable(runId, status) {
 function unsupportedKind(kind) {
   return new AppError("UNSUPPORTED_KIND", `Kind '${kind}' is not supported in this version`, 400);
 }
+function notImplemented(message) {
+  return new AppError("NOT_IMPLEMENTED", message, 501);
+}
 
 // ../contracts/src/google.ts
-import { z as z4 } from "zod";
-var googleConnectionTypeSchema = z4.enum(["gsc", "ga4"]);
-var googleConnectionDtoSchema = z4.object({
-  id: z4.string(),
-  domain: z4.string(),
-  connectionType: googleConnectionTypeSchema,
-  propertyId: z4.string().nullable().optional(),
-  sitemapUrl: z4.string().nullable().optional(),
-  scopes: z4.array(z4.string()).default([]),
-  createdAt: z4.string(),
-  updatedAt: z4.string()
-});
-var gscSearchDataDtoSchema = z4.object({
-  date: z4.string(),
-  query: z4.string(),
-  page: z4.string(),
-  country: z4.string().nullable().optional(),
-  device: z4.string().nullable().optional(),
-  clicks: z4.number(),
-  impressions: z4.number(),
-  ctr: z4.number(),
-  position: z4.number()
-});
-var gscUrlInspectionDtoSchema = z4.object({
-  id: z4.string(),
-  url: z4.string(),
-  indexingState: z4.string().nullable().optional(),
-  verdict: z4.string().nullable().optional(),
-  coverageState: z4.string().nullable().optional(),
-  pageFetchState: z4.string().nullable().optional(),
-  robotsTxtState: z4.string().nullable().optional(),
-  crawlTime: z4.string().nullable().optional(),
-  lastCrawlResult: z4.string().nullable().optional(),
-  isMobileFriendly: z4.boolean().nullable().optional(),
-  richResults: z4.array(z4.string()).default([]),
-  inspectedAt: z4.string()
-});
-var indexTransitionSchema = z4.enum(["stable", "reindexed", "deindexed", "still-missing", "new"]);
-var gscDeindexedRowSchema = z4.object({
-  url: z4.string(),
-  previousState: z4.string().nullable(),
-  currentState: z4.string().nullable(),
-  transitionDate: z4.string()
-});
-var gscReasonGroupSchema = z4.object({
-  reason: z4.string(),
-  count: z4.number(),
-  urls: z4.array(gscUrlInspectionDtoSchema).default([])
-});
-var gscCoverageSummaryDtoSchema = z4.object({
-  summary: z4.object({
-    total: z4.number(),
-    indexed: z4.number(),
-    notIndexed: z4.number(),
-    deindexed: z4.number(),
-    percentage: z4.number()
-  }),
-  lastInspectedAt: z4.string().nullable(),
-  indexed: z4.array(gscUrlInspectionDtoSchema).default([]),
-  notIndexed: z4.array(gscUrlInspectionDtoSchema).default([]),
-  deindexed: z4.array(gscDeindexedRowSchema).default([]),
-  reasonGroups: z4.array(gscReasonGroupSchema).default([])
-});
-var indexingNotificationDtoSchema = z4.object({
-  url: z4.string(),
-  type: z4.enum(["URL_UPDATED", "URL_DELETED"]),
-  notifiedAt: z4.string()
-});
-var indexingRequestResultDtoSchema = z4.object({
-  url: z4.string(),
-  type: z4.enum(["URL_UPDATED", "URL_DELETED"]),
-  notifiedAt: z4.string(),
-  status: z4.enum(["success", "error"]),
-  error: z4.string().optional()
-});
-var gscCoverageSnapshotDtoSchema = z4.object({
-  date: z4.string(),
-  indexed: z4.number(),
-  notIndexed: z4.number(),
-  reasonBreakdown: z4.record(z4.string(), z4.number()).default({})
-});
-
-// ../contracts/src/bing.ts
 import { z as z5 } from "zod";
-var bingConnectionDtoSchema = z5.object({
+var googleConnectionTypeSchema = z5.enum(["gsc", "ga4"]);
+var googleConnectionDtoSchema = z5.object({
   id: z5.string(),
   domain: z5.string(),
-  siteUrl: z5.string().nullable().optional(),
+  connectionType: googleConnectionTypeSchema,
+  propertyId: z5.string().nullable().optional(),
+  sitemapUrl: z5.string().nullable().optional(),
+  scopes: z5.array(z5.string()).default([]),
   createdAt: z5.string(),
   updatedAt: z5.string()
 });
-var bingUrlInspectionDtoSchema = z5.object({
+var gscSearchDataDtoSchema = z5.object({
+  date: z5.string(),
+  query: z5.string(),
+  page: z5.string(),
+  country: z5.string().nullable().optional(),
+  device: z5.string().nullable().optional(),
+  clicks: z5.number(),
+  impressions: z5.number(),
+  ctr: z5.number(),
+  position: z5.number()
+});
+var gscUrlInspectionDtoSchema = z5.object({
   id: z5.string(),
   url: z5.string(),
-  httpCode: z5.number().nullable().optional(),
-  inIndex: z5.boolean().nullable().optional(),
-  lastCrawledDate: z5.string().nullable().optional(),
-  inIndexDate: z5.string().nullable().optional(),
+  indexingState: z5.string().nullable().optional(),
+  verdict: z5.string().nullable().optional(),
+  coverageState: z5.string().nullable().optional(),
+  pageFetchState: z5.string().nullable().optional(),
+  robotsTxtState: z5.string().nullable().optional(),
+  crawlTime: z5.string().nullable().optional(),
+  lastCrawlResult: z5.string().nullable().optional(),
+  isMobileFriendly: z5.boolean().nullable().optional(),
+  richResults: z5.array(z5.string()).default([]),
   inspectedAt: z5.string()
 });
-var bingCoverageSummaryDtoSchema = z5.object({
+var indexTransitionSchema = z5.enum(["stable", "reindexed", "deindexed", "still-missing", "new"]);
+var gscDeindexedRowSchema = z5.object({
+  url: z5.string(),
+  previousState: z5.string().nullable(),
+  currentState: z5.string().nullable(),
+  transitionDate: z5.string()
+});
+var gscReasonGroupSchema = z5.object({
+  reason: z5.string(),
+  count: z5.number(),
+  urls: z5.array(gscUrlInspectionDtoSchema).default([])
+});
+var gscCoverageSummaryDtoSchema = z5.object({
   summary: z5.object({
     total: z5.number(),
     indexed: z5.number(),
     notIndexed: z5.number(),
+    deindexed: z5.number(),
     percentage: z5.number()
   }),
   lastInspectedAt: z5.string().nullable(),
-  indexed: z5.array(bingUrlInspectionDtoSchema).default([]),
-  notIndexed: z5.array(bingUrlInspectionDtoSchema).default([])
+  indexed: z5.array(gscUrlInspectionDtoSchema).default([]),
+  notIndexed: z5.array(gscUrlInspectionDtoSchema).default([]),
+  deindexed: z5.array(gscDeindexedRowSchema).default([]),
+  reasonGroups: z5.array(gscReasonGroupSchema).default([])
 });
-var bingKeywordStatsDtoSchema = z5.object({
-  query: z5.string(),
-  impressions: z5.number(),
-  clicks: z5.number(),
-  ctr: z5.number(),
-  averagePosition: z5.number()
+var indexingNotificationDtoSchema = z5.object({
+  url: z5.string(),
+  type: z5.enum(["URL_UPDATED", "URL_DELETED"]),
+  notifiedAt: z5.string()
 });
-var bingSubmitResultDtoSchema = z5.object({
+var indexingRequestResultDtoSchema = z5.object({
   url: z5.string(),
+  type: z5.enum(["URL_UPDATED", "URL_DELETED"]),
+  notifiedAt: z5.string(),
   status: z5.enum(["success", "error"]),
-  submittedAt: z5.string(),
   error: z5.string().optional()
 });
+var gscCoverageSnapshotDtoSchema = z5.object({
+  date: z5.string(),
+  indexed: z5.number(),
+  notIndexed: z5.number(),
+  reasonBreakdown: z5.record(z5.string(), z5.number()).default({})
+});
 
-// ../contracts/src/project.ts
+// ../contracts/src/bing.ts
 import { z as z6 } from "zod";
-var configSourceSchema = z6.enum(["cli", "api", "config-file"]);
-var projectDtoSchema = z6.object({
+var bingConnectionDtoSchema = z6.object({
   id: z6.string(),
-  name: z6.string(),
-  displayName: z6.string().optional(),
-  canonicalDomain: z6.string(),
-  ownedDomains: z6.array(z6.string()).default([]),
-  country: z6.string().length(2),
-  language: z6.string().min(2),
-  tags: z6.array(z6.string()).default([]),
-  labels: z6.record(z6.string(), z6.string()).default({}),
-  locations: z6.array(locationContextSchema).default([]),
-  defaultLocation: z6.string().nullable().optional(),
-  configSource: configSourceSchema.default("cli"),
-  configRevision: z6.number().int().positive().default(1),
-  createdAt: z6.string().optional(),
-  updatedAt: z6.string().optional()
+  domain: z6.string(),
+  siteUrl: z6.string().nullable().optional(),
+  createdAt: z6.string(),
+  updatedAt: z6.string()
+});
+var bingUrlInspectionDtoSchema = z6.object({
+  id: z6.string(),
+  url: z6.string(),
+  httpCode: z6.number().nullable().optional(),
+  inIndex: z6.boolean().nullable().optional(),
+  lastCrawledDate: z6.string().nullable().optional(),
+  inIndexDate: z6.string().nullable().optional(),
+  inspectedAt: z6.string()
+});
+var bingCoverageSummaryDtoSchema = z6.object({
+  summary: z6.object({
+    total: z6.number(),
+    indexed: z6.number(),
+    notIndexed: z6.number(),
+    percentage: z6.number()
+  }),
+  lastInspectedAt: z6.string().nullable(),
+  indexed: z6.array(bingUrlInspectionDtoSchema).default([]),
+  notIndexed: z6.array(bingUrlInspectionDtoSchema).default([])
+});
+var bingKeywordStatsDtoSchema = z6.object({
+  query: z6.string(),
+  impressions: z6.number(),
+  clicks: z6.number(),
+  ctr: z6.number(),
+  averagePosition: z6.number()
+});
+var bingSubmitResultDtoSchema = z6.object({
+  url: z6.string(),
+  status: z6.enum(["success", "error"]),
+  submittedAt: z6.string(),
+  error: z6.string().optional()
 });
-function normalizeProjectDomain(input) {
-  let domain = input.trim().toLowerCase();
-  try {
-    if (domain.includes("://")) {
-      domain = new URL(domain).hostname.toLowerCase();
-    }
-  } catch {
-  }
-  return domain.replace(/^www\./, "");
-}
-function effectiveDomains(project) {
-  const all = [project.canonicalDomain, ...project.ownedDomains ?? []];
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const d of all) {
-    const trimmed = d.trim();
-    if (!trimmed) continue;
-    const norm = normalizeProjectDomain(trimmed);
-    if (seen.has(norm)) continue;
-    seen.add(norm);
-    result.push(trimmed);
-  }
-  return result;
-}
 
 // ../contracts/src/run.ts
 import { z as z7 } from "zod";
@@ -622,6 +608,16 @@ var scheduleDtoSchema = z8.object({
   createdAt: z8.string(),
   updatedAt: z8.string()
 });
+var scheduleUpsertRequestSchema = z8.object({
+  preset: z8.string().optional(),
+  cron: z8.string().optional(),
+  timezone: z8.string().optional().default("UTC"),
+  enabled: z8.boolean().optional().default(true),
+  providers: z8.array(providerNameSchema).optional().default([])
+}).refine(
+  (data) => data.preset && !data.cron || !data.preset && data.cron,
+  { message: 'Exactly one of "preset" or "cron" must be provided' }
+);
 
 // ../contracts/src/source-categories.ts
 var SOURCE_CATEGORY_RULES = [
@@ -1214,7 +1210,44 @@ var MIGRATIONS = [
   // v10: Add sitemapUrl to google_connections for persistent sitemap storage
   `ALTER TABLE google_connections ADD COLUMN sitemap_url TEXT`,
   // v11: CDP browser provider — screenshot path for captured evidence
-  `ALTER TABLE query_snapshots ADD COLUMN screenshot_path TEXT`
+  `ALTER TABLE query_snapshots ADD COLUMN screenshot_path TEXT`,
+  // v12: Bing Webmaster Tools — bing_connections table
+  `CREATE TABLE IF NOT EXISTS bing_connections (
+    id          TEXT PRIMARY KEY,
+    domain      TEXT NOT NULL,
+    site_url    TEXT,
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT NOT NULL
+  )`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_bing_conn_domain ON bing_connections(domain)`,
+  // v12: Bing Webmaster Tools — bing_url_inspections table
+  `CREATE TABLE IF NOT EXISTS bing_url_inspections (
+    id                TEXT PRIMARY KEY,
+    project_id        TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    url               TEXT NOT NULL,
+    http_code         INTEGER,
+    in_index          INTEGER,
+    last_crawled_date TEXT,
+    in_index_date     TEXT,
+    inspected_at      TEXT NOT NULL,
+    created_at        TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_bing_inspect_project_url ON bing_url_inspections(project_id, url)`,
+  `CREATE INDEX IF NOT EXISTS idx_bing_inspect_url_time ON bing_url_inspections(url, inspected_at)`,
+  // v12: Bing Webmaster Tools — bing_keyword_stats table
+  `CREATE TABLE IF NOT EXISTS bing_keyword_stats (
+    id               TEXT PRIMARY KEY,
+    project_id       TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    query            TEXT NOT NULL,
+    impressions      INTEGER NOT NULL DEFAULT 0,
+    clicks           INTEGER NOT NULL DEFAULT 0,
+    ctr              TEXT NOT NULL DEFAULT '0',
+    average_position TEXT NOT NULL DEFAULT '0',
+    synced_at        TEXT NOT NULL,
+    created_at       TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_bing_keyword_project ON bing_keyword_stats(project_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_bing_keyword_query ON bing_keyword_stats(query)`
 ];
 function migrate(db) {
   const statements = MIGRATION_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -1297,17 +1330,46 @@ function writeAuditLog(db, entry) {
 async function projectRoutes(app, opts) {
   app.put("/projects/:name", async (request, reply) => {
     const { name } = request.params;
-    const body = request.body;
-    if (!body || !body.displayName || !body.canonicalDomain || !body.country || !body.language) {
-      const err = validationError("Missing required fields: displayName, canonicalDomain, country, language");
+    const parsedBody = projectUpsertRequestSchema.safeParse(request.body);
+    if (!parsedBody.success) {
+      const err = validationError("Invalid project payload", {
+        issues: parsedBody.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      });
       return reply.status(err.statusCode).send(err.toJSON());
     }
-    if (body.ownedDomains !== void 0 && (!Array.isArray(body.ownedDomains) || body.ownedDomains.some((d) => typeof d !== "string" || d.trim() === ""))) {
-      const err = validationError("ownedDomains must be an array of non-empty strings");
-      return reply.status(err.statusCode).send(err.toJSON());
+    const body = parsedBody.data;
+    const validNames = opts.validProviderNames ?? [];
+    if (validNames.length && body.providers?.length) {
+      const invalid = body.providers.filter((p) => !validNames.includes(p));
+      if (invalid.length) {
+        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          invalidProviders: invalid,
+          validProviders: validNames
+        });
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(projects).where(eq3(projects.name, name)).get();
+    const existingLocations = existing ? JSON.parse(existing.locations || "[]") : [];
+    const nextLocations = body.locations ?? existingLocations;
+    const duplicateLabels = findDuplicateLocationLabels(nextLocations);
+    if (duplicateLabels.length > 0) {
+      const err = validationError(`Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`, {
+        duplicateLabels
+      });
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    const nextDefaultLocation = body.defaultLocation !== void 0 ? body.defaultLocation ?? null : existing?.defaultLocation ?? null;
+    if (!hasLocationLabel(nextLocations, nextDefaultLocation)) {
+      const err = validationError(`defaultLocation "${nextDefaultLocation}" must match a configured location label`, {
+        defaultLocation: nextDefaultLocation
+      });
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
     if (existing) {
       app.db.update(projects).set({
         displayName: body.displayName,
@@ -1318,8 +1380,8 @@ async function projectRoutes(app, opts) {
         tags: JSON.stringify(body.tags ?? []),
         labels: JSON.stringify(body.labels ?? {}),
         providers: JSON.stringify(body.providers ?? []),
-        locations: JSON.stringify(body.locations ?? JSON.parse(existing.locations || "[]")),
-        defaultLocation: body.defaultLocation !== void 0 ? body.defaultLocation ?? null : existing.defaultLocation,
+        locations: JSON.stringify(nextLocations),
+        defaultLocation: nextDefaultLocation,
         configSource: body.configSource ?? "api",
         configRevision: existing.configRevision + 1,
         updatedAt: now
@@ -1346,8 +1408,8 @@ async function projectRoutes(app, opts) {
       tags: JSON.stringify(body.tags ?? []),
       labels: JSON.stringify(body.labels ?? {}),
       providers: JSON.stringify(body.providers ?? []),
-      locations: JSON.stringify(body.locations ?? []),
-      defaultLocation: body.defaultLocation ?? null,
+      locations: JSON.stringify(nextLocations),
+      defaultLocation: nextDefaultLocation,
       configSource: body.configSource ?? "api",
       configRevision: 1,
       createdAt: now,
@@ -1712,9 +1774,13 @@ async function keywordRoutes(app, opts) {
       const err = validationError('Body must contain a "provider" string');
       return reply.status(err.statusCode).send(err.toJSON());
     }
-    const provider = parseProviderName(body.provider);
-    if (!provider) {
-      const err = validationError(`Unknown provider "${body.provider}". Valid providers: gemini, openai, claude, local`);
+    const provider = body.provider.trim().toLowerCase();
+    const validNames = opts.validProviderNames ?? [];
+    if (validNames.length && !validNames.includes(provider)) {
+      const err = validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
+        provider: body.provider,
+        validProviders: validNames
+      });
       return reply.status(err.statusCode).send(err.toJSON());
     }
     if (body.count !== void 0 && (typeof body.count !== "number" || !Number.isFinite(body.count) || !Number.isInteger(body.count))) {
@@ -1723,7 +1789,8 @@ async function keywordRoutes(app, opts) {
     }
     const count = Math.min(Math.max(body.count ?? 5, 1), 20);
     if (!opts.onGenerateKeywords) {
-      return reply.status(501).send({ error: "Key phrase generation is not supported in this deployment" });
+      const err = notImplemented("Key phrase generation is not supported in this deployment");
+      return reply.status(err.statusCode).send(err.toJSON());
     }
     const existingRows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     const existingKeywords = existingRows.map((r) => r.keyword);
@@ -1739,7 +1806,10 @@ async function keywordRoutes(app, opts) {
     } catch (err) {
       request.log.error({ err }, "Key phrase generation failed");
       return reply.status(500).send({
-        error: err instanceof Error ? err.message : "Failed to generate key phrases"
+        error: {
+          code: "INTERNAL_ERROR",
+          message: err instanceof Error ? err.message : "Failed to generate key phrases"
+        }
       });
     }
   });
@@ -1813,7 +1883,7 @@ function resolveProjectSafe2(app, name, reply) {
 
 // ../api-routes/src/runs.ts
 import crypto8 from "crypto";
-import { eq as eq7, asc } from "drizzle-orm";
+import { eq as eq7, asc, desc } from "drizzle-orm";
 
 // ../api-routes/src/run-queue.ts
 import crypto7 from "crypto";
@@ -1860,12 +1930,19 @@ async function runRoutes(app, opts) {
     const trigger = request.body?.trigger ?? "manual";
     const rawProviders = request.body?.providers;
     if (rawProviders?.length) {
-      const parsed = rawProviders.map((p) => parseProviderName(p));
-      const invalid = rawProviders.filter((_, i) => !parsed[i]);
-      if (invalid.length) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Invalid provider(s): ${invalid.join(", ")}. Must be one of: gemini, openai, claude, local` } });
+      const normalized = rawProviders.map((p) => p.trim().toLowerCase()).filter(Boolean);
+      const validNames = opts.validProviderNames ?? [];
+      if (validNames.length) {
+        const invalid = normalized.filter((p) => !validNames.includes(p));
+        if (invalid.length) {
+          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+            invalidProviders: invalid,
+            validProviders: validNames
+          });
+          return reply.status(err.statusCode).send(err.toJSON());
+        }
       }
-      rawProviders.splice(0, rawProviders.length, ...parsed.filter(Boolean));
+      rawProviders.splice(0, rawProviders.length, ...normalized);
     }
     const providers = rawProviders?.length ? rawProviders : void 0;
     let resolvedLocation;
@@ -1944,7 +2021,9 @@ async function runRoutes(app, opts) {
   app.get("/projects/:name/runs", async (request, reply) => {
     const project = resolveProjectSafe3(app, request.params.name, reply);
     if (!project) return;
-    const rows = app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(asc(runs.createdAt)).all();
+    const parsedLimit = parseInt(request.query.limit ?? "", 10);
+    const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? void 0 : parsedLimit;
+    const rows = limit == null ? app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(asc(runs.createdAt)).all() : app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(desc(runs.createdAt)).limit(limit).all().reverse();
     return reply.send(rows.map(formatRun));
   });
   app.get("/runs", async (_request, reply) => {
@@ -1963,12 +2042,19 @@ async function runRoutes(app, opts) {
     }
     const rawProviders = request.body?.providers;
     if (rawProviders?.length) {
-      const parsed = rawProviders.map((p) => parseProviderName(p));
-      const invalid = rawProviders.filter((_, i) => !parsed[i]);
-      if (invalid.length) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Invalid provider(s): ${invalid.join(", ")}. Must be one of: gemini, openai, claude, local` } });
+      const normalized = rawProviders.map((p) => p.trim().toLowerCase()).filter(Boolean);
+      const validNames = opts.validProviderNames ?? [];
+      if (validNames.length) {
+        const invalid = normalized.filter((p) => !validNames.includes(p));
+        if (invalid.length) {
+          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+            invalidProviders: invalid,
+            validProviders: validNames
+          });
+          return reply.status(err.statusCode).send(err.toJSON());
+        }
       }
-      rawProviders.splice(0, rawProviders.length, ...parsed.filter(Boolean));
+      rawProviders.splice(0, rawProviders.length, ...normalized);
     }
     const providers = rawProviders?.length ? rawProviders : void 0;
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -2371,6 +2457,23 @@ async function applyRoutes(app, opts) {
       return reply.status(err.statusCode).send(err.toJSON());
     }
     const config = parsed.data;
+    const validNames = opts?.validProviderNames ?? [];
+    if (validNames.length) {
+      const allProviders = [
+        ...config.spec.providers ?? [],
+        ...config.spec.schedule?.providers ?? []
+      ];
+      if (allProviders.length) {
+        const invalid = allProviders.filter((p) => !validNames.includes(p));
+        if (invalid.length) {
+          const err = validationError(`Invalid provider(s): ${[...new Set(invalid)].join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+            invalidProviders: [...new Set(invalid)],
+            validProviders: validNames
+          });
+          return reply.status(err.statusCode).send(err.toJSON());
+        }
+      }
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const name = config.metadata.name;
     const existing = app.db.select().from(projects).where(eq8(projects.name, name)).get();
@@ -2578,16 +2681,16 @@ async function applyRoutes(app, opts) {
 }
 
 // ../api-routes/src/history.ts
-import { eq as eq9, desc, inArray } from "drizzle-orm";
+import { eq as eq9, desc as desc2, inArray } from "drizzle-orm";
 async function historyRoutes(app) {
   app.get("/projects/:name/history", async (request, reply) => {
     const project = resolveProjectSafe4(app, request.params.name, reply);
     if (!project) return;
-    const rows = app.db.select().from(auditLog).where(eq9(auditLog.projectId, project.id)).orderBy(desc(auditLog.createdAt)).all();
+    const rows = app.db.select().from(auditLog).where(eq9(auditLog.projectId, project.id)).orderBy(desc2(auditLog.createdAt)).all();
     return reply.send(rows.map(formatAuditEntry));
   });
   app.get("/history", async (_request, reply) => {
-    const rows = app.db.select().from(auditLog).orderBy(desc(auditLog.createdAt)).all();
+    const rows = app.db.select().from(auditLog).orderBy(desc2(auditLog.createdAt)).all();
     return reply.send(rows.map(formatAuditEntry));
   });
   app.get("/projects/:name/snapshots", async (request, reply) => {
@@ -2612,7 +2715,7 @@ async function historyRoutes(app) {
       competitorOverlap: querySnapshots.competitorOverlap,
       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(desc(querySnapshots.createdAt)).all();
+    }).from(querySnapshots).leftJoin(keywords, eq9(querySnapshots.keywordId, keywords.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;
@@ -2793,7 +2896,7 @@ function resolveProjectSafe4(app, name, reply) {
 }
 
 // ../api-routes/src/analytics.ts
-import { eq as eq10, desc as desc2, inArray as inArray2 } from "drizzle-orm";
+import { eq as eq10, desc as desc3, inArray as inArray2 } from "drizzle-orm";
 async function analyticsRoutes(app) {
   app.get("/projects/:name/analytics/metrics", async (request, reply) => {
     const project = resolveProjectSafe5(app, request.params.name, reply);
@@ -2837,7 +2940,7 @@ async function analyticsRoutes(app) {
     if (!project) return;
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
-    const latestRun = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc2(runs.createdAt)).all().find((r) => r.status === "completed" || r.status === "partial");
+    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: [], runId: "", window });
     }
@@ -2919,7 +3022,7 @@ async function analyticsRoutes(app) {
     if (!project) return;
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
-    const windowRuns = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc2(runs.createdAt)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
+    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 });
     }
@@ -3035,14 +3138,16 @@ function computeBuckets(snapshots, projectRuns, bucketDays) {
     const startISO = start.toISOString();
     const endISO = end.toISOString();
     const inBucket = snapshots.filter((s) => s.createdAt >= startISO && s.createdAt < endISO);
-    const metric = computeProviderMetric(inBucket);
-    buckets.push({
-      startDate: startISO,
-      endDate: endISO,
-      citationRate: metric.citationRate,
-      cited: metric.cited,
-      total: metric.total
-    });
+    if (inBucket.length > 0) {
+      const metric = computeProviderMetric(inBucket);
+      buckets.push({
+        startDate: startISO,
+        endDate: endISO,
+        citationRate: metric.citationRate,
+        cited: metric.cited,
+        total: metric.total
+      });
+    }
     start = end;
   }
   return buckets;
@@ -3130,7 +3235,7 @@ var providerNameParameter = {
   in: "path",
   required: true,
   description: "Provider name.",
-  schema: { type: "string", enum: ["gemini", "openai", "claude", "local"] }
+  schema: { type: "string", enum: ["gemini", "openai", "claude", "perplexity", "local"] }
 };
 var locationLabelParameter = {
   name: "label",
@@ -3439,7 +3544,7 @@ var routeCatalog = [
             type: "object",
             required: ["provider"],
             properties: {
-              provider: { type: "string", enum: ["gemini", "openai", "claude", "local"] },
+              provider: { type: "string", enum: ["gemini", "openai", "claude", "perplexity", "local"] },
               count: integerSchema
             }
           }
@@ -3518,7 +3623,7 @@ var routeCatalog = [
     path: "/api/v1/projects/{name}/runs",
     summary: "List project runs",
     tags: ["runs"],
-    parameters: [nameParameter],
+    parameters: [nameParameter, limitQueryParameter],
     responses: {
       200: { description: "Runs returned." }
     }
@@ -4601,31 +4706,40 @@ async function settingsRoutes(app, opts) {
     bing: opts.bing ?? { configured: false }
   }));
   app.put("/settings/providers/:name", async (request, reply) => {
-    const providerName = parseProviderName(request.params.name);
     const { apiKey, baseUrl, model, quota } = request.body ?? {};
-    if (!providerName) {
-      return reply.status(400).send({ error: `Invalid provider: ${request.params.name}. Must be one of: gemini, openai, claude, local` });
+    const name = request.params.name;
+    const adapters = opts.providerAdapters ?? [];
+    const apiAdapters = adapters.filter((a) => a.mode === "api");
+    const adapterInfo = apiAdapters.find((a) => a.name === name);
+    if (!adapterInfo) {
+      const validNames = apiAdapters.map((a) => a.name);
+      const err = validationError(`Invalid provider: ${name}. Must be one of: ${validNames.join(", ")}`, {
+        provider: name,
+        validProviders: validNames
+      });
+      return reply.status(err.statusCode).send(err.toJSON());
     }
-    const name = providerName;
     if (name === "local") {
       if (!baseUrl || typeof baseUrl !== "string") {
-        return reply.status(400).send({ error: "baseUrl is required for local provider" });
+        const err = validationError("baseUrl is required for local provider");
+        return reply.status(err.statusCode).send(err.toJSON());
       }
     } else {
       if (!apiKey || typeof apiKey !== "string") {
-        return reply.status(400).send({ error: "apiKey is required" });
+        const err = validationError("apiKey is required");
+        return reply.status(err.statusCode).send(err.toJSON());
       }
     }
     if (model !== void 0) {
-      const registry = MODEL_REGISTRY[name];
-      if (!registry.validationPattern.test(model)) {
+      if (!adapterInfo.modelValidationPattern.test(model)) {
         return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid model "${model}" for provider "${name}" \u2014 ${registry.validationHint}` }
+          error: { code: "VALIDATION_ERROR", message: `Invalid model "${model}" for provider "${name}" \u2014 ${adapterInfo.modelValidationHint}` }
         });
       }
     }
     if (!opts.onProviderUpdate) {
-      return reply.status(501).send({ error: "Provider configuration updates are not supported in this deployment" });
+      const err = notImplemented("Provider configuration updates are not supported in this deployment");
+      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (quota !== void 0) {
       if (typeof quota !== "object" || quota === null) {
@@ -4642,7 +4756,12 @@ async function settingsRoutes(app, opts) {
     }
     const result = opts.onProviderUpdate(name, apiKey ?? "", model, baseUrl, quota);
     if (!result) {
-      return reply.status(500).send({ error: "Failed to update provider configuration" });
+      return reply.status(500).send({
+        error: {
+          code: "INTERNAL_ERROR",
+          message: "Failed to update provider configuration"
+        }
+      });
     }
     return result;
   });
@@ -4654,11 +4773,17 @@ async function settingsRoutes(app, opts) {
       });
     }
     if (!opts.onGoogleUpdate) {
-      return reply.status(501).send({ error: "Google OAuth configuration updates are not supported in this deployment" });
+      const err = notImplemented("Google OAuth configuration updates are not supported in this deployment");
+      return reply.status(err.statusCode).send(err.toJSON());
     }
     const result = opts.onGoogleUpdate(clientId, clientSecret);
     if (!result) {
-      return reply.status(500).send({ error: "Failed to update Google OAuth configuration" });
+      return reply.status(500).send({
+        error: {
+          code: "INTERNAL_ERROR",
+          message: "Failed to update Google OAuth configuration"
+        }
+      });
     }
     return result;
   });
@@ -4670,11 +4795,17 @@ async function settingsRoutes(app, opts) {
       });
     }
     if (!opts.onBingUpdate) {
-      return reply.status(501).send({ error: "Bing configuration updates are not supported in this deployment" });
+      const err = notImplemented("Bing configuration updates are not supported in this deployment");
+      return reply.status(err.statusCode).send(err.toJSON());
     }
     const result = opts.onBingUpdate(apiKey);
     if (!result) {
-      return reply.status(500).send({ error: "Failed to update Bing configuration" });
+      return reply.status(500).send({
+        error: {
+          code: "INTERNAL_ERROR",
+          message: "Failed to update Bing configuration"
+        }
+      });
     }
     return result;
   });
@@ -4684,7 +4815,8 @@ async function settingsRoutes(app, opts) {
 async function telemetryRoutes(app, opts) {
   app.get("/telemetry", async (_request, reply) => {
     if (!opts.getTelemetryStatus) {
-      return reply.status(501).send({ error: "Telemetry status is not available in this deployment" });
+      const err = notImplemented("Telemetry status is not available in this deployment");
+      return reply.status(err.statusCode).send(err.toJSON());
     }
     const status = opts.getTelemetryStatus();
     return {
@@ -4694,11 +4826,13 @@ async function telemetryRoutes(app, opts) {
   });
   app.put("/telemetry", async (request, reply) => {
     if (!opts.setTelemetryEnabled) {
-      return reply.status(501).send({ error: "Telemetry configuration is not available in this deployment" });
+      const err = notImplemented("Telemetry configuration is not available in this deployment");
+      return reply.status(err.statusCode).send(err.toJSON());
     }
     const { enabled } = request.body ?? {};
     if (typeof enabled !== "boolean") {
-      return reply.status(400).send({ error: "enabled (boolean) is required" });
+      const err = validationError("enabled (boolean) is required");
+      return reply.status(err.statusCode).send(err.toJSON());
     }
     opts.setTelemetryEnabled(enabled);
     const status = opts.getTelemetryStatus?.();
@@ -4716,11 +4850,27 @@ async function scheduleRoutes(app, opts) {
   app.put("/projects/:name/schedule", async (request, reply) => {
     const project = resolveProjectSafe6(app, request.params.name, reply);
     if (!project) return;
-    const { preset, cron: cron2, timezone = "UTC", providers = [], enabled = true } = request.body ?? {};
-    if (!preset && !cron2 || preset && cron2) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: 'Exactly one of "preset" or "cron" must be provided' }
+    const parsedBody = scheduleUpsertRequestSchema.safeParse(request.body);
+    if (!parsedBody.success) {
+      const err = validationError("Invalid schedule payload", {
+        issues: parsedBody.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
       });
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
+    const { preset, cron: cron2, timezone, providers, enabled } = parsedBody.data;
+    const validNames = opts.validProviderNames ?? [];
+    if (validNames.length && providers?.length) {
+      const invalid = providers.filter((p) => !validNames.includes(p));
+      if (invalid.length) {
+        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          invalidProviders: invalid,
+          validProviders: validNames
+        });
+        return reply.status(err.statusCode).send(err.toJSON());
+      }
     }
     if (!isValidTimezone(timezone)) {
       return reply.status(400).send({
@@ -4991,7 +5141,7 @@ function resolveProjectSafe7(app, name, reply) {
 
 // ../api-routes/src/google.ts
 import crypto13 from "crypto";
-import { eq as eq13, and as and3, desc as desc3, sql as sql2 } from "drizzle-orm";
+import { eq as eq13, and as and3, desc as desc4, sql as sql2 } from "drizzle-orm";
 
 // ../integration-google/src/constants.ts
 var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
@@ -5432,7 +5582,7 @@ async function googleRoutes(app, opts) {
     if (endDate) conditions.push(sql2`${gscSearchData.date} <= ${endDate}`);
     if (query) conditions.push(sql2`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
     if (page) conditions.push(sql2`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
-    const rows = app.db.select().from(gscSearchData).where(and3(...conditions)).orderBy(desc3(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
+    const rows = app.db.select().from(gscSearchData).where(and3(...conditions)).orderBy(desc4(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
     return rows.map((r) => ({
       date: r.date,
       query: r.query,
@@ -5510,7 +5660,7 @@ async function googleRoutes(app, opts) {
     const { url, limit } = request.query;
     const conditions = [eq13(gscUrlInspections.projectId, project.id)];
     if (url) conditions.push(eq13(gscUrlInspections.url, url));
-    const rows = app.db.select().from(gscUrlInspections).where(and3(...conditions)).orderBy(desc3(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
+    const rows = app.db.select().from(gscUrlInspections).where(and3(...conditions)).orderBy(desc4(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
     return rows.map((r) => ({
       id: r.id,
       url: r.url,
@@ -5529,7 +5679,7 @@ async function googleRoutes(app, opts) {
   });
   app.get("/projects/:name/google/gsc/deindexed", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const allInspections = app.db.select().from(gscUrlInspections).where(eq13(gscUrlInspections.projectId, project.id)).orderBy(desc3(gscUrlInspections.inspectedAt)).all();
+    const allInspections = app.db.select().from(gscUrlInspections).where(eq13(gscUrlInspections.projectId, project.id)).orderBy(desc4(gscUrlInspections.inspectedAt)).all();
     const byUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       const existing = byUrl.get(row.url);
@@ -5557,7 +5707,7 @@ async function googleRoutes(app, opts) {
   });
   app.get("/projects/:name/google/gsc/coverage", async (request) => {
     const project = resolveProject(app.db, request.params.name);
-    const allInspections = app.db.select().from(gscUrlInspections).where(eq13(gscUrlInspections.projectId, project.id)).orderBy(desc3(gscUrlInspections.inspectedAt)).all();
+    const allInspections = app.db.select().from(gscUrlInspections).where(eq13(gscUrlInspections.projectId, project.id)).orderBy(desc4(gscUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const historyByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
@@ -5649,7 +5799,7 @@ async function googleRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const parsed = parseInt(request.query.limit ?? "90", 10);
     const limit = Number.isNaN(parsed) || parsed <= 0 ? 90 : parsed;
-    const rows = app.db.select().from(gscCoverageSnapshots).where(eq13(gscCoverageSnapshots.projectId, project.id)).orderBy(desc3(gscCoverageSnapshots.date)).limit(limit).all();
+    const rows = app.db.select().from(gscCoverageSnapshots).where(eq13(gscCoverageSnapshots.projectId, project.id)).orderBy(desc4(gscCoverageSnapshots.date)).limit(limit).all();
     return rows.map((r) => ({
       date: r.date,
       indexed: r.indexed,
@@ -5802,7 +5952,7 @@ async function googleRoutes(app, opts) {
     const { accessToken } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
     let urlsToNotify = request.body?.urls ?? [];
     if (request.body?.allUnindexed) {
-      const allInspections = app.db.select().from(gscUrlInspections).where(eq13(gscUrlInspections.projectId, project.id)).orderBy(desc3(gscUrlInspections.inspectedAt)).all();
+      const allInspections = app.db.select().from(gscUrlInspections).where(eq13(gscUrlInspections.projectId, project.id)).orderBy(desc4(gscUrlInspections.inspectedAt)).all();
       const latestByUrl = /* @__PURE__ */ new Map();
       for (const row of allInspections) {
         if (!latestByUrl.has(row.url)) {
@@ -5877,7 +6027,7 @@ async function googleRoutes(app, opts) {
 
 // ../api-routes/src/bing.ts
 import crypto14 from "crypto";
-import { eq as eq14, and as and4, desc as desc4 } from "drizzle-orm";
+import { eq as eq14, and as and4, desc as desc5 } from "drizzle-orm";
 
 // ../integration-bing/src/constants.ts
 var BING_WMT_API_BASE = "https://ssl.bing.com/webmaster/api.svc/json";
@@ -6081,7 +6231,7 @@ async function bingRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const conn = requireConnection(store, project.canonicalDomain, reply);
     if (!conn) return;
-    const allInspections = app.db.select().from(bingUrlInspections).where(eq14(bingUrlInspections.projectId, project.id)).orderBy(desc4(bingUrlInspections.inspectedAt)).all();
+    const allInspections = app.db.select().from(bingUrlInspections).where(eq14(bingUrlInspections.projectId, project.id)).orderBy(desc5(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       if (!latestByUrl.has(row.url)) {
@@ -6131,7 +6281,7 @@ async function bingRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
     const whereClause = url ? and4(eq14(bingUrlInspections.projectId, project.id), eq14(bingUrlInspections.url, url)) : eq14(bingUrlInspections.projectId, project.id);
-    const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc4(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
+    const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc5(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
     return filtered.map((r) => ({
       id: r.id,
       url: r.url,
@@ -6193,7 +6343,7 @@ async function bingRoutes(app, opts) {
     }
     let urlsToSubmit = request.body?.urls ?? [];
     if (request.body?.allUnindexed) {
-      const allInspections = app.db.select().from(bingUrlInspections).where(eq14(bingUrlInspections.projectId, project.id)).orderBy(desc4(bingUrlInspections.inspectedAt)).all();
+      const allInspections = app.db.select().from(bingUrlInspections).where(eq14(bingUrlInspections.projectId, project.id)).orderBy(desc5(bingUrlInspections.inspectedAt)).all();
       const latestByUrl = /* @__PURE__ */ new Map();
       for (const row of allInspections) {
         if (!latestByUrl.has(row.url)) {
@@ -6289,51 +6439,61 @@ async function cdpRoutes(app, opts) {
     const { snapshotId } = request.params;
     const snapshot = app.db.select({ screenshotPath: querySnapshots.screenshotPath }).from(querySnapshots).where(eq15(querySnapshots.id, snapshotId)).get();
     if (!snapshot?.screenshotPath) {
-      return reply.code(404).send({ error: "Screenshot not found" });
+      const err = notFound("Screenshot", snapshotId);
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     const base = path2.resolve(getScreenshotDir());
     const fullPath = path2.resolve(path2.join(base, snapshot.screenshotPath));
     if (!fullPath.startsWith(base + path2.sep) && fullPath !== base) {
-      return reply.code(404).send({ error: "Screenshot not found" });
+      const err = notFound("Screenshot", snapshotId);
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     if (!fs2.existsSync(fullPath)) {
-      return reply.code(404).send({ error: "Screenshot file not found on disk" });
+      const err = notFound("Screenshot file", snapshotId);
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     const stream = fs2.createReadStream(fullPath);
     return reply.type("image/png").send(stream);
   });
   app.put("/settings/cdp", async (request, reply) => {
     if (!opts.onCdpConfigure) {
-      return reply.code(501).send({ error: "CDP configuration not supported in this deployment" });
+      const err = notImplemented("CDP configuration not supported in this deployment");
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     const { host, port = 9222 } = request.body;
     if (!host || typeof host !== "string") {
-      return reply.code(400).send({ error: "host is required" });
+      const err = validationError("host is required");
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     const ALLOWED_HOSTS = ["localhost", "127.0.0.1", "::1"];
     if (!ALLOWED_HOSTS.includes(host)) {
-      return reply.code(400).send({ error: "host must be localhost, 127.0.0.1, or ::1" });
+      const err = validationError("host must be localhost, 127.0.0.1, or ::1");
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     if (!Number.isInteger(port) || port < 1 || port > 65535) {
-      return reply.code(400).send({ error: "port must be an integer between 1 and 65535" });
+      const err = validationError("port must be an integer between 1 and 65535");
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     await opts.onCdpConfigure(host, port);
     return reply.code(200).send({ endpoint: `ws://${host}:${port}` });
   });
   app.get("/cdp/status", async (_request, reply) => {
     if (!opts.getCdpStatus) {
-      return reply.code(501).send({ error: "CDP not configured" });
+      const err = notImplemented("CDP not configured");
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     const status = await opts.getCdpStatus();
     return reply.send(status);
   });
   app.post("/cdp/screenshot", async (request, reply) => {
     if (!opts.onCdpScreenshot) {
-      return reply.code(501).send({ error: "CDP not configured" });
+      const err = notImplemented("CDP not configured");
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     const { query, targets } = request.body;
     if (!query || typeof query !== "string") {
-      return reply.code(400).send({ error: "query is required" });
+      const err = validationError("query is required");
+      return reply.code(err.statusCode).send(err.toJSON());
     }
     const results = await opts.onCdpScreenshot(query, targets);
     return reply.code(200).send({ results });
@@ -6344,7 +6504,10 @@ async function cdpRoutes(app, opts) {
       const project = resolveProject(app.db, request.params.name);
       const { runId } = request.params;
       const run = app.db.select().from(runs).where(and5(eq15(runs.id, runId), eq15(runs.projectId, project.id))).get();
-      if (!run) return reply.code(404).send({ error: "Run not found" });
+      if (!run) {
+        const err = notFound("Run", runId);
+        return reply.code(err.statusCode).send(err.toJSON());
+      }
       const snapshots = app.db.select({
         id: querySnapshots.id,
         keywordId: querySnapshots.keywordId,
@@ -6465,15 +6628,21 @@ async function apiRoutes(app, opts) {
   await app.register(async (api) => {
     await api.register(openApiRoutes, opts.openApiInfo ?? {});
     await api.register(projectRoutes, {
-      onProjectDeleted: opts.onProjectDeleted
+      onProjectDeleted: opts.onProjectDeleted,
+      validProviderNames: opts.providerAdapters?.map((a) => a.name)
     });
     await api.register(keywordRoutes, {
-      onGenerateKeywords: opts.onGenerateKeywords
+      onGenerateKeywords: opts.onGenerateKeywords,
+      validProviderNames: opts.providerAdapters?.filter((a) => a.mode === "api").map((a) => a.name)
     });
     await api.register(competitorRoutes);
-    await api.register(runRoutes, { onRunCreated: opts.onRunCreated });
+    await api.register(runRoutes, {
+      onRunCreated: opts.onRunCreated,
+      validProviderNames: opts.providerAdapters?.map((a) => a.name)
+    });
     await api.register(applyRoutes, {
       onScheduleUpdated: opts.onScheduleUpdated,
+      validProviderNames: opts.providerAdapters?.map((a) => a.name),
       onGoogleConnectionPropertyUpdated: (domain, connectionType, propertyId) => {
         opts.googleConnectionStore?.updateConnection(domain, connectionType, {
           propertyId,
@@ -6485,6 +6654,7 @@ async function apiRoutes(app, opts) {
     await api.register(analyticsRoutes);
     await api.register(settingsRoutes, {
       providerSummary: opts.providerSummary,
+      providerAdapters: opts.providerAdapters,
       onProviderUpdate: opts.onProviderUpdate,
       google: opts.googleSettingsSummary,
       onGoogleUpdate: opts.onGoogleSettingsUpdate,
@@ -6492,7 +6662,8 @@ async function apiRoutes(app, opts) {
       onBingUpdate: opts.onBingSettingsUpdate
     });
     await api.register(scheduleRoutes, {
-      onScheduleUpdated: opts.onScheduleUpdated
+      onScheduleUpdated: opts.onScheduleUpdated,
+      validProviderNames: opts.providerAdapters?.map((a) => a.name)
     });
     await api.register(notificationRoutes);
     await api.register(telemetryRoutes, {
@@ -6520,11 +6691,12 @@ async function apiRoutes(app, opts) {
 
 // ../provider-gemini/src/normalize.ts
 import { GoogleGenerativeAI } from "@google/generative-ai";
-var DEFAULT_MODEL = getDefaultModel("gemini");
+var DEFAULT_MODEL = "gemini-3-flash";
+var VALIDATION_PATTERN = /^gemini-/;
 function resolveModel(config) {
   const m = config.model;
   if (!m) return DEFAULT_MODEL;
-  if (isValidModelName("gemini", m)) return m;
+  if (VALIDATION_PATTERN.test(m)) return m;
   console.warn(
     `[provider-gemini] Invalid model name "${m}" \u2014 this provider uses the Gemini AI Studio API (generativelanguage.googleapis.com) which only accepts "gemini-*" model names. Falling back to ${DEFAULT_MODEL}.`
   );
@@ -6535,7 +6707,7 @@ function validateConfig(config) {
     return { ok: false, provider: "gemini", message: "missing api key" };
   }
   const model = resolveModel(config);
-  const warning = config.model && !isValidModelName("gemini", config.model) ? ` (invalid model "${config.model}" replaced with default)` : "";
+  const warning = config.model && !VALIDATION_PATTERN.test(config.model) ? ` (invalid model "${config.model}" replaced with default)` : "";
   return {
     ok: true,
     provider: "gemini",
@@ -6719,12 +6891,26 @@ function toGeminiConfig(config) {
 }
 var geminiAdapter = {
   name: "gemini",
-  validateConfig(config) {
-    const result = validateConfig(toGeminiConfig(config));
-    return {
-      ok: result.ok,
-      provider: "gemini",
-      message: result.message,
+  displayName: "Gemini",
+  mode: "api",
+  keyUrl: "https://aistudio.google.com/apikey",
+  modelRegistry: {
+    defaultModel: "gemini-3-flash",
+    validationPattern: /^gemini-/,
+    validationHint: 'model name must start with "gemini-" (e.g. gemini-3-flash)',
+    knownModels: [
+      { id: "gemini-3.1-pro-preview", displayName: "Gemini 3.1 Pro (Preview)", tier: "flagship" },
+      { id: "gemini-3-flash-preview", displayName: "Gemini 3 Flash (Preview)", tier: "standard" },
+      { id: "gemini-3.1-flash-lite-preview", displayName: "Gemini 3.1 Flash-Lite (Preview)", tier: "economy" },
+      { id: "gemini-2.5-flash", displayName: "Gemini 2.5 Flash", tier: "standard" }
+    ]
+  },
+  validateConfig(config) {
+    const result = validateConfig(toGeminiConfig(config));
+    return {
+      ok: result.ok,
+      provider: "gemini",
+      message: result.message,
       model: result.model
     };
   },
@@ -6777,7 +6963,7 @@ var geminiAdapter = {
 
 // ../provider-openai/src/normalize.ts
 import OpenAI from "openai";
-var DEFAULT_MODEL2 = getDefaultModel("openai");
+var DEFAULT_MODEL2 = "gpt-5.4";
 function validateConfig2(config) {
   if (!config.apiKey || config.apiKey.length === 0) {
     return { ok: false, provider: "openai", message: "missing api key" };
@@ -6971,6 +7157,22 @@ function toOpenAIConfig(config) {
 }
 var openaiAdapter = {
   name: "openai",
+  displayName: "OpenAI",
+  mode: "api",
+  keyUrl: "https://platform.openai.com/api-keys",
+  modelRegistry: {
+    defaultModel: "gpt-5.4",
+    validationPattern: /^(gpt-|o\d)/,
+    validationHint: "expected a GPT or o-series model name (e.g. gpt-5.4, o3)",
+    knownModels: [
+      { id: "gpt-5.4", displayName: "GPT-5.4", tier: "flagship" },
+      { id: "gpt-5.4-pro", displayName: "GPT-5.4 Pro", tier: "flagship" },
+      { id: "gpt-5-mini", displayName: "GPT-5 Mini", tier: "fast" },
+      { id: "gpt-5-nano", displayName: "GPT-5 Nano", tier: "economy" },
+      { id: "gpt-5", displayName: "GPT-5", tier: "standard" },
+      { id: "gpt-4.1", displayName: "GPT-4.1", tier: "standard" }
+    ]
+  },
   validateConfig(config) {
     const result = validateConfig2(toOpenAIConfig(config));
     return {
@@ -7029,7 +7231,7 @@ var openaiAdapter = {
 
 // ../provider-claude/src/normalize.ts
 import Anthropic from "@anthropic-ai/sdk";
-var DEFAULT_MODEL3 = getDefaultModel("claude");
+var DEFAULT_MODEL3 = "claude-sonnet-4-6";
 function validateConfig3(config) {
   if (!config.apiKey || config.apiKey.length === 0) {
     return { ok: false, provider: "claude", message: "missing api key" };
@@ -7217,6 +7419,19 @@ function toClaudeConfig(config) {
 }
 var claudeAdapter = {
   name: "claude",
+  displayName: "Claude",
+  mode: "api",
+  keyUrl: "https://platform.claude.com/settings/keys",
+  modelRegistry: {
+    defaultModel: "claude-sonnet-4-6",
+    validationPattern: /^claude-/,
+    validationHint: 'model name must start with "claude-" (e.g. claude-sonnet-4-6)',
+    knownModels: [
+      { id: "claude-opus-4-6", displayName: "Claude Opus 4.6", tier: "flagship" },
+      { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6", tier: "standard" },
+      { id: "claude-haiku-4-5", displayName: "Claude Haiku 4.5", tier: "fast" }
+    ]
+  },
   validateConfig(config) {
     const result = validateConfig3(toClaudeConfig(config));
     return {
@@ -7275,7 +7490,7 @@ var claudeAdapter = {
 
 // ../provider-local/src/normalize.ts
 import OpenAI2 from "openai";
-var DEFAULT_MODEL4 = getDefaultModel("local");
+var DEFAULT_MODEL4 = "llama3";
 function validateConfig4(config) {
   if (!config.baseUrl || config.baseUrl.length === 0) {
     return { ok: false, provider: "local", message: "missing base URL" };
@@ -7404,6 +7619,16 @@ function toLocalConfig(config) {
 }
 var localAdapter = {
   name: "local",
+  displayName: "Local",
+  mode: "api",
+  modelRegistry: {
+    defaultModel: "llama3",
+    validationPattern: /./,
+    validationHint: "any model name accepted",
+    knownModels: [
+      { id: "llama3", displayName: "Llama 3", tier: "standard" }
+    ]
+  },
   validateConfig(config) {
     const result = validateConfig4(toLocalConfig(config));
     return {
@@ -7920,6 +8145,16 @@ function getScreenshotDir2() {
 }
 var cdpChatgptAdapter = {
   name: "cdp:chatgpt",
+  displayName: "ChatGPT (Browser)",
+  mode: "browser",
+  modelRegistry: {
+    defaultModel: "chatgpt-web",
+    validationPattern: /./,
+    validationHint: "model is detected from the ChatGPT web UI",
+    knownModels: [
+      { id: "chatgpt-web", displayName: "ChatGPT (Web UI)", tier: "standard" }
+    ]
+  },
   validateConfig(config) {
     if (!config.cdpEndpoint) {
       return {
@@ -8000,6 +8235,215 @@ var cdpChatgptAdapter = {
   }
 };
 
+// ../provider-perplexity/src/normalize.ts
+import OpenAI3 from "openai";
+var DEFAULT_MODEL5 = "sonar";
+var BASE_URL = "https://api.perplexity.ai";
+function validateConfig5(config) {
+  if (!config.apiKey || config.apiKey.length === 0) {
+    return { ok: false, provider: "perplexity", message: "missing api key" };
+  }
+  return {
+    ok: true,
+    provider: "perplexity",
+    message: "config valid",
+    model: config.model ?? DEFAULT_MODEL5
+  };
+}
+async function healthcheck5(config) {
+  const validation = validateConfig5(config);
+  if (!validation.ok) return validation;
+  try {
+    const client = new OpenAI3({ apiKey: config.apiKey, baseURL: BASE_URL });
+    const response = await client.chat.completions.create({
+      model: config.model ?? DEFAULT_MODEL5,
+      messages: [{ role: "user", content: 'Say "ok"' }]
+    });
+    const text2 = response.choices[0]?.message?.content ?? "";
+    return {
+      ok: text2.length > 0,
+      provider: "perplexity",
+      message: text2.length > 0 ? "perplexity api key verified" : "empty response from perplexity",
+      model: config.model ?? DEFAULT_MODEL5
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      provider: "perplexity",
+      message: err instanceof Error ? err.message : String(err),
+      model: config.model ?? DEFAULT_MODEL5
+    };
+  }
+}
+async function executeTrackedQuery5(input) {
+  const model = input.config.model ?? DEFAULT_MODEL5;
+  const client = new OpenAI3({ apiKey: input.config.apiKey, baseURL: BASE_URL });
+  const response = await client.chat.completions.create({
+    model,
+    messages: [
+      { role: "user", content: input.keyword }
+    ]
+  });
+  const rawResponse = responseToRecord4(response);
+  const citations = extractCitations(rawResponse);
+  const groundingSources = citations.map((url) => ({
+    uri: url,
+    title: ""
+  }));
+  return {
+    provider: "perplexity",
+    rawResponse,
+    model,
+    groundingSources,
+    searchQueries: [input.keyword]
+  };
+}
+function normalizeResult6(raw) {
+  const answerText = extractAnswerText3(raw.rawResponse);
+  const citedDomains = extractCitedDomains5(raw.groundingSources);
+  return {
+    provider: "perplexity",
+    answerText,
+    citedDomains,
+    groundingSources: raw.groundingSources,
+    searchQueries: raw.searchQueries
+  };
+}
+function extractCitations(rawResponse) {
+  if (Array.isArray(rawResponse.citations)) {
+    return rawResponse.citations.filter((c) => typeof c === "string");
+  }
+  const apiResponse = rawResponse.apiResponse;
+  if (apiResponse !== null && typeof apiResponse === "object" && !Array.isArray(apiResponse)) {
+    const nested = apiResponse.citations;
+    if (Array.isArray(nested)) {
+      return nested.filter((c) => typeof c === "string");
+    }
+  }
+  return [];
+}
+function extractAnswerText3(rawResponse) {
+  try {
+    const choices = rawResponse.choices;
+    if (!choices?.length) return "";
+    return choices[0].message?.content ?? "";
+  } catch {
+    return "";
+  }
+}
+function extractCitedDomains5(groundingSources) {
+  const domains = /* @__PURE__ */ new Set();
+  for (const source of groundingSources) {
+    const domain = extractDomainFromUri4(source.uri);
+    if (domain) domains.add(domain);
+  }
+  return [...domains];
+}
+function extractDomainFromUri4(uri) {
+  try {
+    const url = new URL(uri);
+    return url.hostname.replace(/^www\./, "");
+  } catch {
+    return null;
+  }
+}
+async function generateText5(prompt, config) {
+  const model = config.model ?? DEFAULT_MODEL5;
+  const client = new OpenAI3({ apiKey: config.apiKey, baseURL: BASE_URL });
+  const response = await client.chat.completions.create({
+    model,
+    messages: [{ role: "user", content: prompt }]
+  });
+  return response.choices[0]?.message?.content ?? "";
+}
+function responseToRecord4(response) {
+  try {
+    return JSON.parse(JSON.stringify(response));
+  } catch {
+    return { error: "failed to serialize response" };
+  }
+}
+
+// ../provider-perplexity/src/adapter.ts
+function toPerplexityConfig(config) {
+  return {
+    apiKey: config.apiKey ?? "",
+    model: config.model,
+    quotaPolicy: config.quotaPolicy
+  };
+}
+var perplexityAdapter = {
+  name: "perplexity",
+  displayName: "Perplexity",
+  mode: "api",
+  keyUrl: "https://www.perplexity.ai/settings/api",
+  modelRegistry: {
+    defaultModel: "sonar",
+    validationPattern: /^sonar/,
+    validationHint: "expected a sonar model (e.g. sonar, sonar-pro, sonar-reasoning)",
+    knownModels: [
+      { id: "sonar", displayName: "Sonar", tier: "standard" },
+      { id: "sonar-pro", displayName: "Sonar Pro", tier: "flagship" },
+      { id: "sonar-reasoning", displayName: "Sonar Reasoning", tier: "flagship" },
+      { id: "sonar-reasoning-pro", displayName: "Sonar Reasoning Pro", tier: "flagship" }
+    ]
+  },
+  validateConfig(config) {
+    const result = validateConfig5(toPerplexityConfig(config));
+    return {
+      ok: result.ok,
+      provider: "perplexity",
+      message: result.message,
+      model: result.model
+    };
+  },
+  async healthcheck(config) {
+    const result = await healthcheck5(toPerplexityConfig(config));
+    return {
+      ok: result.ok,
+      provider: "perplexity",
+      message: result.message,
+      model: result.model
+    };
+  },
+  async executeTrackedQuery(input, config) {
+    const raw = await executeTrackedQuery5({
+      keyword: input.keyword,
+      canonicalDomains: input.canonicalDomains,
+      competitorDomains: input.competitorDomains,
+      config: toPerplexityConfig(config),
+      location: input.location
+    });
+    return {
+      provider: "perplexity",
+      rawResponse: raw.rawResponse,
+      model: raw.model,
+      groundingSources: raw.groundingSources,
+      searchQueries: raw.searchQueries
+    };
+  },
+  normalizeResult(raw) {
+    const perplexityRaw = {
+      provider: "perplexity",
+      rawResponse: raw.rawResponse,
+      model: raw.model,
+      groundingSources: raw.groundingSources,
+      searchQueries: raw.searchQueries
+    };
+    const normalized = normalizeResult6(perplexityRaw);
+    return {
+      provider: "perplexity",
+      answerText: normalized.answerText,
+      citedDomains: normalized.citedDomains,
+      groundingSources: normalized.groundingSources,
+      searchQueries: normalized.searchQueries
+    };
+  },
+  async generateText(prompt, config) {
+    return generateText5(prompt, toPerplexityConfig(config));
+  }
+};
+
 // src/google-config.ts
 function ensureConnections(config) {
   if (!config.google) config.google = {};
@@ -8078,7 +8522,75 @@ import crypto15 from "crypto";
 import fs4 from "fs";
 import path5 from "path";
 import os4 from "os";
-import { eq as eq16, inArray as inArray3 } from "drizzle-orm";
+import { and as and6, eq as eq16, inArray as inArray3 } from "drizzle-orm";
+var RunCancelledError = class extends Error {
+  constructor(runId) {
+    super(`Run ${runId} was cancelled`);
+    this.name = "RunCancelledError";
+  }
+};
+var ProviderExecutionGate = class {
+  constructor(maxConcurrency, maxPerMinute) {
+    this.maxConcurrency = maxConcurrency;
+    this.maxPerMinute = maxPerMinute;
+  }
+  window = [];
+  waiters = [];
+  rateLimitChain = Promise.resolve();
+  inFlight = 0;
+  async run(task) {
+    await this.acquire();
+    try {
+      await this.waitForRateLimit();
+      return await task();
+    } finally {
+      this.release();
+    }
+  }
+  async acquire() {
+    if (this.inFlight < Math.max(1, this.maxConcurrency)) {
+      this.inFlight++;
+      return;
+    }
+    await new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+    this.inFlight++;
+  }
+  release() {
+    this.inFlight = Math.max(0, this.inFlight - 1);
+    const next = this.waiters.shift();
+    next?.();
+  }
+  async waitForRateLimit() {
+    let releaseChain;
+    const previousChain = this.rateLimitChain;
+    this.rateLimitChain = new Promise((resolve) => {
+      releaseChain = resolve;
+    });
+    await previousChain;
+    try {
+      const now = Date.now();
+      const windowStart = now - 6e4;
+      while (this.window.length > 0 && this.window[0] < windowStart) {
+        this.window.shift();
+      }
+      if (this.window.length >= this.maxPerMinute) {
+        const oldestInWindow = this.window[0];
+        const waitMs = oldestInWindow + 6e4 - now + 50;
+        await new Promise((resolve) => setTimeout(resolve, waitMs));
+        const nowAfterWait = Date.now();
+        const newWindowStart = nowAfterWait - 6e4;
+        while (this.window.length > 0 && this.window[0] < newWindowStart) {
+          this.window.shift();
+        }
+      }
+      this.window.push(Date.now());
+    } finally {
+      releaseChain?.();
+    }
+  }
+};
 var JobRunner = class {
   db;
   registry;
@@ -8099,13 +8611,34 @@ var JobRunner = class {
   async executeRun(runId, projectId, providerOverride, locationOverride) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const startTime = Date.now();
+    let runLocation;
+    let activeProviders = [];
+    let projectKeywords = [];
+    const providerDispatchCounts = /* @__PURE__ */ new Map();
     try {
-      this.db.update(runs).set({ status: "running", startedAt: now }).where(eq16(runs.id, runId)).run();
+      const existingRun = this.getRunState(runId);
+      if (!existingRun) {
+        throw new Error(`Run ${runId} not found`);
+      }
+      if (existingRun.status === "cancelled") {
+        this.handleCancelledRun(runId, projectId, startTime, {
+          providerCount: 0,
+          providers: [],
+          keywordCount: 0
+        });
+        return;
+      }
+      if (existingRun.status !== "queued" && existingRun.status !== "running") {
+        throw new Error(`Run ${runId} is not executable from status '${existingRun.status}'`);
+      }
+      if (existingRun.status === "queued") {
+        this.db.update(runs).set({ status: "running", startedAt: now }).where(and6(eq16(runs.id, runId), eq16(runs.status, "queued"))).run();
+      }
+      this.throwIfRunCancelled(runId);
       const project = this.db.select().from(projects).where(eq16(projects.id, projectId)).get();
       if (!project) {
         throw new Error(`Project ${projectId} not found`);
       }
-      let runLocation;
       if (locationOverride === null) {
         runLocation = void 0;
       } else if (locationOverride) {
@@ -8117,16 +8650,26 @@ var JobRunner = class {
         }
       }
       const projectProviders = providerOverride ?? JSON.parse(project.providers || "[]");
-      const activeProviders = this.registry.getForProject(projectProviders);
+      activeProviders = this.registry.getForProject(projectProviders);
       if (activeProviders.length === 0) {
         throw new Error("No providers configured. Add at least one provider API key.");
       }
       console.log(`[JobRunner] Run ${runId}: dispatching to ${activeProviders.length} providers: ${activeProviders.map((p) => p.adapter.name).join(", ")}`);
-      const projectKeywords = this.db.select().from(keywords).where(eq16(keywords.projectId, projectId)).all();
+      projectKeywords = this.db.select().from(keywords).where(eq16(keywords.projectId, projectId)).all();
       const projectCompetitors = this.db.select().from(competitors).where(eq16(competitors.projectId, projectId)).all();
       const competitorDomains = projectCompetitors.map((c) => c.domain);
+      const allDomains = effectiveDomains({
+        canonicalDomain: project.canonicalDomain,
+        ownedDomains: JSON.parse(project.ownedDomains || "[]")
+      });
+      const executionContext = {
+        providerCount: activeProviders.length,
+        providers: activeProviders.map((provider) => provider.adapter.name),
+        keywordCount: projectKeywords.length,
+        ...runLocation ? { location: runLocation.label } : {}
+      };
       const queriesPerProvider = projectKeywords.length;
-      const todayPeriod = getCurrentPeriod();
+      const todayPeriod = getCurrentUsageDay();
       for (const p of activeProviders) {
         const providerScope = `${projectId}:${p.adapter.name}`;
         const providerUsage = this.db.select().from(usageCounters).where(eq16(usageCounters.scope, providerScope)).all().filter((r) => r.period === todayPeriod && r.metric === "queries").reduce((sum, r) => sum + r.count, 0);
@@ -8137,27 +8680,31 @@ var JobRunner = class {
           );
         }
       }
-      const minuteWindows = /* @__PURE__ */ new Map();
-      for (const p of activeProviders) {
-        minuteWindows.set(p.adapter.name, []);
+      const executionGates = /* @__PURE__ */ new Map();
+      for (const provider of activeProviders) {
+        executionGates.set(
+          provider.adapter.name,
+          new ProviderExecutionGate(
+            provider.config.quotaPolicy.maxConcurrency,
+            provider.config.quotaPolicy.maxRequestsPerMinute
+          )
+        );
       }
       const providerErrors = /* @__PURE__ */ new Map();
       let totalSnapshotsInserted = 0;
       const apiProviders = activeProviders.filter((p) => !isBrowserProvider(p.adapter.name));
       const browserProviders = activeProviders.filter((p) => isBrowserProvider(p.adapter.name));
-      for (const kw of projectKeywords) {
-        const providerPromises = apiProviders.map(async (registeredProvider) => {
-          const { adapter, config } = registeredProvider;
-          const providerName = adapter.name;
-          try {
-            await this.waitForRateLimit(
-              minuteWindows.get(providerName),
-              config.quotaPolicy.maxRequestsPerMinute
-            );
-            const allDomains = effectiveDomains({
-              canonicalDomain: project.canonicalDomain,
-              ownedDomains: JSON.parse(project.ownedDomains || "[]")
-            });
+      const processKeywordForProvider = async (registeredProvider, kw) => {
+        const { adapter, config } = registeredProvider;
+        const providerName = adapter.name;
+        const gate = executionGates.get(providerName);
+        if (!gate) {
+          throw new Error(`Missing execution gate for provider ${providerName}`);
+        }
+        try {
+          await gate.run(async () => {
+            this.throwIfRunCancelled(runId);
+            providerDispatchCounts.set(providerName, (providerDispatchCounts.get(providerName) ?? 0) + 1);
             const raw = await adapter.executeTrackedQuery(
               {
                 keyword: kw.keyword,
@@ -8167,6 +8714,7 @@ var JobRunner = class {
               },
               config
             );
+            this.throwIfRunCancelled(runId);
             const normalized = adapter.normalizeResult(raw);
             console.log(`[JobRunner] ${providerName}: "${kw.keyword}" citedDomains=${JSON.stringify(normalized.citedDomains)}, groundingSources=${JSON.stringify(normalized.groundingSources.map((s) => s.uri))}, domains=${JSON.stringify(allDomains)}`);
             const citationState = determineCitationState(normalized, allDomains);
@@ -8222,96 +8770,29 @@ var JobRunner = class {
             }
             totalSnapshotsInserted++;
             console.log(`[JobRunner] ${providerName}: keyword "${kw.keyword}" \u2192 ${citationState}`);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`[JobRunner] ${providerName}: keyword "${kw.keyword}" FAILED: ${msg}`);
-            providerErrors.set(providerName, msg);
+          });
+        } catch (err) {
+          if (err instanceof RunCancelledError) {
+            throw err;
           }
-        });
-        await Promise.all(providerPromises);
-        for (const registeredProvider of browserProviders) {
-          const { adapter, config } = registeredProvider;
-          const providerName = adapter.name;
-          try {
-            await this.waitForRateLimit(
-              minuteWindows.get(providerName),
-              config.quotaPolicy.maxRequestsPerMinute
-            );
-            const allDomains = effectiveDomains({
-              canonicalDomain: project.canonicalDomain,
-              ownedDomains: JSON.parse(project.ownedDomains || "[]")
-            });
-            const raw = await adapter.executeTrackedQuery(
-              {
-                keyword: kw.keyword,
-                canonicalDomains: allDomains,
-                competitorDomains,
-                location: runLocation
-              },
-              config
-            );
-            const normalized = adapter.normalizeResult(raw);
-            console.log(`[JobRunner] ${providerName}: "${kw.keyword}" citedDomains=${JSON.stringify(normalized.citedDomains)}, groundingSources=${JSON.stringify(normalized.groundingSources.map((s) => s.uri))}, domains=${JSON.stringify(allDomains)}`);
-            const citationState = determineCitationState(normalized, allDomains);
-            const overlap = computeCompetitorOverlap(normalized, competitorDomains);
-            let screenshotRelPath = null;
-            if (raw.screenshotPath && fs4.existsSync(raw.screenshotPath)) {
-              const snapshotId = crypto15.randomUUID();
-              const screenshotDir = path5.join(os4.homedir(), ".canonry", "screenshots", runId);
-              if (!fs4.existsSync(screenshotDir)) fs4.mkdirSync(screenshotDir, { recursive: true });
-              const destPath = path5.join(screenshotDir, `${snapshotId}.png`);
-              fs4.renameSync(raw.screenshotPath, destPath);
-              screenshotRelPath = `${runId}/${snapshotId}.png`;
-              this.db.insert(querySnapshots).values({
-                id: snapshotId,
-                runId,
-                keywordId: kw.id,
-                provider: providerName,
-                model: raw.model,
-                citationState,
-                answerText: normalized.answerText,
-                citedDomains: JSON.stringify(normalized.citedDomains),
-                competitorOverlap: JSON.stringify(overlap),
-                location: runLocation?.label ?? null,
-                screenshotPath: screenshotRelPath,
-                rawResponse: JSON.stringify({
-                  model: raw.model,
-                  groundingSources: normalized.groundingSources,
-                  searchQueries: normalized.searchQueries,
-                  apiResponse: raw.rawResponse
-                }),
-                createdAt: (/* @__PURE__ */ new Date()).toISOString()
-              }).run();
-            } else {
-              this.db.insert(querySnapshots).values({
-                id: crypto15.randomUUID(),
-                runId,
-                keywordId: kw.id,
-                provider: providerName,
-                model: raw.model,
-                citationState,
-                answerText: normalized.answerText,
-                citedDomains: JSON.stringify(normalized.citedDomains),
-                competitorOverlap: JSON.stringify(overlap),
-                location: runLocation?.label ?? null,
-                rawResponse: JSON.stringify({
-                  model: raw.model,
-                  groundingSources: normalized.groundingSources,
-                  searchQueries: normalized.searchQueries,
-                  apiResponse: raw.rawResponse
-                }),
-                createdAt: (/* @__PURE__ */ new Date()).toISOString()
-              }).run();
-            }
-            totalSnapshotsInserted++;
-            console.log(`[JobRunner] ${providerName}: keyword "${kw.keyword}" \u2192 ${citationState}`);
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.error(`[JobRunner] ${providerName}: keyword "${kw.keyword}" FAILED: ${msg}`);
+          const msg = err instanceof Error ? err.message : String(err);
+          console.error(`[JobRunner] ${providerName}: keyword "${kw.keyword}" FAILED: ${msg}`);
+          if (!providerErrors.has(providerName)) {
             providerErrors.set(providerName, msg);
           }
         }
+      };
+      await Promise.all(apiProviders.map(async (registeredProvider) => {
+        await Promise.all(projectKeywords.map(async (kw) => {
+          await processKeywordForProvider(registeredProvider, kw);
+        }));
+      }));
+      for (const registeredProvider of browserProviders) {
+        for (const kw of projectKeywords) {
+          await processKeywordForProvider(registeredProvider, kw);
+        }
       }
+      this.throwIfRunCancelled(runId);
       const allFailed = totalSnapshotsInserted === 0 && providerErrors.size > 0;
       const someFailed = providerErrors.size > 0;
       if (allFailed) {
@@ -8323,18 +8804,16 @@ var JobRunner = class {
       } else {
         this.db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq16(runs.id, runId)).run();
       }
+      this.flushProviderUsage(projectId, providerDispatchCounts);
       const finalStatus = allFailed ? "failed" : someFailed ? "partial" : "completed";
       trackEvent("run.completed", {
         status: finalStatus,
-        providerCount: activeProviders.length,
-        providers: activeProviders.map((p) => p.adapter.name),
-        keywordCount: projectKeywords.length,
+        providerCount: executionContext.providerCount,
+        providers: executionContext.providers,
+        keywordCount: executionContext.keywordCount,
         durationMs: Date.now() - startTime,
-        ...runLocation ? { location: runLocation.label } : {}
+        ...executionContext.location ? { location: executionContext.location } : {}
       });
-      for (const p of activeProviders) {
-        this.incrementUsage(`${projectId}:${p.adapter.name}`, "queries", queriesPerProvider);
-      }
       this.incrementUsage(projectId, "runs", 1);
       if (this.onRunCompleted) {
         this.onRunCompleted(runId, projectId).catch((err) => {
@@ -8342,18 +8821,31 @@ var JobRunner = class {
         });
       }
     } catch (err) {
+      const executionContext = {
+        providerCount: activeProviders.length,
+        providers: activeProviders.map((provider) => provider.adapter.name),
+        keywordCount: projectKeywords.length,
+        ...runLocation ? { location: runLocation.label } : {}
+      };
+      if (err instanceof RunCancelledError || this.isRunCancelled(runId)) {
+        this.flushProviderUsage(projectId, providerDispatchCounts);
+        this.handleCancelledRun(runId, projectId, startTime, executionContext);
+        return;
+      }
       const errorMessage = err instanceof Error ? err.message : String(err);
       this.db.update(runs).set({
         status: "failed",
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: errorMessage
       }).where(eq16(runs.id, runId)).run();
+      this.flushProviderUsage(projectId, providerDispatchCounts);
       trackEvent("run.completed", {
         status: "failed",
-        providerCount: 0,
-        providers: [],
-        keywordCount: 0,
-        durationMs: Date.now() - startTime
+        providerCount: executionContext.providerCount,
+        providers: executionContext.providers,
+        keywordCount: executionContext.keywordCount,
+        durationMs: Date.now() - startTime,
+        ...executionContext.location ? { location: executionContext.location } : {}
       });
       if (this.onRunCompleted) {
         this.onRunCompleted(runId, projectId).catch((notifErr) => {
@@ -8362,27 +8854,9 @@ var JobRunner = class {
       }
     }
   }
-  async waitForRateLimit(window, maxPerMinute) {
-    const now = Date.now();
-    const windowStart = now - 6e4;
-    while (window.length > 0 && window[0] < windowStart) {
-      window.shift();
-    }
-    if (window.length >= maxPerMinute) {
-      const oldestInWindow = window[0];
-      const waitMs = oldestInWindow + 6e4 - now + 50;
-      await new Promise((resolve) => setTimeout(resolve, waitMs));
-      const nowAfterWait = Date.now();
-      const newWindowStart = nowAfterWait - 6e4;
-      while (window.length > 0 && window[0] < newWindowStart) {
-        window.shift();
-      }
-    }
-    window.push(Date.now());
-  }
   incrementUsage(scope, metric, count) {
     const now = /* @__PURE__ */ new Date();
-    const period = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}`;
+    const period = now.toISOString().slice(0, 10);
     const id = crypto15.randomUUID();
     const existing = this.db.select().from(usageCounters).where(eq16(usageCounters.scope, scope)).all().find((r) => r.period === period && r.metric === metric);
     if (existing) {
@@ -8398,10 +8872,52 @@ var JobRunner = class {
       }).run();
     }
   }
+  flushProviderUsage(projectId, providerDispatchCounts) {
+    for (const [providerName, count] of providerDispatchCounts.entries()) {
+      if (count <= 0) continue;
+      this.incrementUsage(`${projectId}:${providerName}`, "queries", count);
+    }
+  }
+  getRunState(runId) {
+    return this.db.select({
+      status: runs.status,
+      finishedAt: runs.finishedAt,
+      error: runs.error
+    }).from(runs).where(eq16(runs.id, runId)).get();
+  }
+  isRunCancelled(runId) {
+    return this.getRunState(runId)?.status === "cancelled";
+  }
+  throwIfRunCancelled(runId) {
+    if (this.isRunCancelled(runId)) {
+      throw new RunCancelledError(runId);
+    }
+  }
+  handleCancelledRun(runId, projectId, startTime, context) {
+    const currentRun = this.getRunState(runId);
+    if (currentRun && !currentRun.finishedAt) {
+      this.db.update(runs).set({
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: currentRun.error ?? "Cancelled by user"
+      }).where(eq16(runs.id, runId)).run();
+    }
+    trackEvent("run.completed", {
+      status: "cancelled",
+      providerCount: context.providerCount,
+      providers: context.providers,
+      keywordCount: context.keywordCount,
+      durationMs: Date.now() - startTime,
+      ...context.location ? { location: context.location } : {}
+    });
+    if (this.onRunCompleted) {
+      this.onRunCompleted(runId, projectId).catch((err) => {
+        console.error("[JobRunner] Notification callback failed:", err);
+      });
+    }
+  }
 };
-function getCurrentPeriod() {
-  const d = /* @__PURE__ */ new Date();
-  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
+function getCurrentUsageDay() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 function domainMatches(domain, canonicalDomain) {
   const normalized = normalizeProjectDomain(canonicalDomain);
@@ -8467,7 +8983,7 @@ function computeCompetitorOverlap(normalized, competitorDomains) {
 
 // src/gsc-sync.ts
 import crypto16 from "crypto";
-import { eq as eq17, and as and6, sql as sql3 } from "drizzle-orm";
+import { eq as eq17, and as and7, sql as sql3 } from "drizzle-orm";
 function formatDate(d) {
   return d.toISOString().split("T")[0];
 }
@@ -8518,7 +9034,7 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     console.log(`[GSC Sync] Received ${rows.length} rows`);
     db.delete(gscSearchData).where(
-      and6(
+      and7(
         eq17(gscSearchData.projectId, projectId),
         sql3`${gscSearchData.date} >= ${startDate}`,
         sql3`${gscSearchData.date} <= ${endDate}`
@@ -8607,7 +9123,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = formatDate(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and6(eq17(gscCoverageSnapshots.projectId, projectId), eq17(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and7(eq17(gscCoverageSnapshots.projectId, projectId), eq17(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto16.randomUUID(),
       projectId,
@@ -8630,7 +9146,7 @@ async function executeGscSync(db, runId, projectId, opts) {
 
 // src/gsc-inspect-sitemap.ts
 import crypto17 from "crypto";
-import { eq as eq18, and as and7 } from "drizzle-orm";
+import { eq as eq18, and as and8 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var LOC_REGEX = /<loc>\s*([^<]+?)\s*<\/loc>/gi;
@@ -8793,7 +9309,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and7(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and8(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto17.randomUUID(),
       projectId,
@@ -8985,7 +9501,7 @@ var Scheduler = class {
 };
 
 // src/notifier.ts
-import { eq as eq20, desc as desc5, and as and8, or as or2 } from "drizzle-orm";
+import { eq as eq20, desc as desc6, and as and9, or as or2 } from "drizzle-orm";
 import crypto18 from "crypto";
 var Notifier = class {
   db;
@@ -9048,11 +9564,11 @@ var Notifier = class {
   }
   computeTransitions(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
-      and8(
+      and9(
         eq20(runs.projectId, projectId),
         or2(eq20(runs.status, "completed"), eq20(runs.status, "partial"))
       )
-    ).orderBy(desc5(runs.createdAt)).limit(2).all();
+    ).orderBy(desc6(runs.createdAt)).limit(2).all();
     if (recentRuns.length < 2) return [];
     const currentRunId = recentRuns[0].id;
     const previousRunId = recentRuns[1].id;
@@ -9255,6 +9771,20 @@ var DEFAULT_QUOTA = {
   maxRequestsPerMinute: 10,
   maxRequestsPerDay: 1e3
 };
+var API_ADAPTERS = [
+  geminiAdapter,
+  openaiAdapter,
+  claudeAdapter,
+  localAdapter,
+  perplexityAdapter
+];
+var BROWSER_ADAPTERS = [
+  cdpChatgptAdapter
+];
+var ALL_ADAPTERS = [...API_ADAPTERS, ...BROWSER_ADAPTERS];
+var adapterMap = Object.fromEntries(
+  API_ADAPTERS.map((a) => [a.name, a])
+);
 function summarizeProviderConfig(provider, config) {
   return {
     configured: Boolean(config?.apiKey || config?.baseUrl),
@@ -9291,38 +9821,19 @@ async function createServer(opts) {
     const p = providers[k];
     return p?.apiKey || p?.baseUrl;
   }));
-  if (providers.gemini?.apiKey) {
-    registry.register(geminiAdapter, {
-      provider: "gemini",
-      apiKey: providers.gemini.apiKey,
-      model: providers.gemini.model,
-      quotaPolicy: providers.gemini.quota ?? DEFAULT_QUOTA
-    });
-  }
-  if (providers.openai?.apiKey) {
-    registry.register(openaiAdapter, {
-      provider: "openai",
-      apiKey: providers.openai.apiKey,
-      model: providers.openai.model,
-      quotaPolicy: providers.openai.quota ?? DEFAULT_QUOTA
-    });
-  }
-  if (providers.claude?.apiKey) {
-    registry.register(claudeAdapter, {
-      provider: "claude",
-      apiKey: providers.claude.apiKey,
-      model: providers.claude.model,
-      quotaPolicy: providers.claude.quota ?? DEFAULT_QUOTA
-    });
-  }
-  if (providers.local?.baseUrl) {
-    registry.register(localAdapter, {
-      provider: "local",
-      apiKey: providers.local.apiKey,
-      baseUrl: providers.local.baseUrl,
-      model: providers.local.model,
-      quotaPolicy: providers.local.quota ?? DEFAULT_QUOTA
-    });
+  for (const adapter of API_ADAPTERS) {
+    const entry = providers[adapter.name];
+    if (!entry) continue;
+    const isConfigured = adapter.name === "local" ? !!entry.baseUrl : !!entry.apiKey;
+    if (isConfigured) {
+      registry.register(adapter, {
+        provider: adapter.name,
+        apiKey: entry.apiKey,
+        baseUrl: entry.baseUrl,
+        model: entry.model,
+        quotaPolicy: entry.quota ?? DEFAULT_QUOTA
+      });
+    }
   }
   const cdpConfig = opts.config.cdp;
   if (cdpConfig?.host || cdpConfig?.port) {
@@ -9347,17 +9858,25 @@ async function createServer(opts) {
       });
     }
   });
-  const providerSummary = ["gemini", "openai", "claude", "local"].map((name) => ({
-    name,
-    model: registry.get(name)?.config.model,
-    configured: !!registry.get(name),
-    quota: registry.get(name)?.config.quotaPolicy
+  const providerSummary = API_ADAPTERS.map((adapter) => ({
+    name: adapter.name,
+    displayName: adapter.displayName,
+    keyUrl: adapter.keyUrl,
+    modelHint: `e.g. ${adapter.modelRegistry.defaultModel}`,
+    model: registry.get(adapter.name)?.config.model,
+    configured: !!registry.get(adapter.name),
+    quota: registry.get(adapter.name)?.config.quotaPolicy
   }));
   const googleSettingsSummary = {
     configured: Boolean(opts.config.google?.clientId && opts.config.google?.clientSecret)
   };
   const bingSettingsSummary = {
-    configured: Boolean(opts.config.bing?.apiKey)
+    // Treat Bing as configured if there is at least one connection with an API key,
+    // OR if a global bing.apiKey is set. The CLI stores keys per-connection
+    // (bing.connections[].apiKey), so checking only bing.apiKey missed existing connections.
+    configured: Boolean(
+      opts.config.bing?.apiKey || opts.config.bing?.connections?.some((c) => c.apiKey)
+    )
   };
   const bingConnectionStore = {
     getConnection: (domain) => {
@@ -9391,7 +9910,6 @@ async function createServer(opts) {
       return true;
     }
   };
-  const adapterMap = { gemini: geminiAdapter, openai: openaiAdapter, claude: claudeAdapter, local: localAdapter };
   const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto19.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
@@ -9455,6 +9973,13 @@ async function createServer(opts) {
       version: PKG_VERSION
     },
     providerSummary,
+    providerAdapters: [...API_ADAPTERS, ...BROWSER_ADAPTERS].map((a) => ({
+      name: a.name,
+      displayName: a.displayName,
+      mode: a.mode,
+      modelValidationPattern: a.modelRegistry.validationPattern,
+      modelValidationHint: a.modelRegistry.validationHint
+    })),
     googleSettingsSummary,
     bingSettingsSummary,
     bingConnectionStore,
@@ -9465,7 +9990,7 @@ async function createServer(opts) {
     },
     onProviderUpdate: (providerName, apiKey, model, baseUrl, incomingQuota) => {
       const name = providerName;
-      if (!(name in adapterMap)) return null;
+      if (!adapterMap[name]) return null;
       if (!opts.config.providers) opts.config.providers = {};
       const existing = opts.config.providers[name];
       const beforeConfig = summarizeProviderConfig(name, existing);
@@ -9748,14 +10273,6 @@ function parseKeywordResponse(raw, count) {
 }
 
 export {
-  providerQuotaPolicySchema,
-  resolveProviderInput,
-  notificationEventSchema,
-  getDefaultModel,
-  effectiveDomains,
-  apiKeys,
-  createClient,
-  migrate,
   getConfigDir,
   getConfigPath,
   loadConfig,
@@ -9766,6 +10283,13 @@ export {
   isFirstRun,
   showFirstRunNotice,
   trackEvent,
+  providerQuotaPolicySchema,
+  resolveProviderInput,
+  notificationEventSchema,
+  effectiveDomains,
   setGoogleAuthConfig,
+  apiKeys,
+  createClient,
+  migrate,
   createServer
 };