@ainyc/canonry 4.69.0 → 4.69.2

package/dist/{chunk-D75O5A27.js → chunk-5FM7QRYD.js}

@@ -570,12 +570,40 @@ var auditLogEntrySchema = z3.object({
   createdAt: z3.string()
 });
 
+// ../contracts/src/api-keys.ts
+import { z as z4 } from "zod";
+var apiKeyDtoSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  /** First 9 chars of the raw token (`cnry_` + 4 hex). Safe to display. */
+  keyPrefix: z4.string(),
+  scopes: z4.array(z4.string()),
+  createdAt: z4.string(),
+  lastUsedAt: z4.string().nullable(),
+  revokedAt: z4.string().nullable()
+});
+var apiKeyListDtoSchema = z4.object({
+  keys: z4.array(apiKeyDtoSchema)
+});
+var createApiKeyRequestSchema = z4.object({
+  name: z4.string().min(1).max(100),
+  /**
+   * Scopes granted to the new key. Omit to default to `['*']` (full access,
+   * what `canonry init` writes for the root key). When provided it must be a
+   * non-empty list — an empty array would mint a key that can do nothing.
+   */
+  scopes: z4.array(z4.string()).min(1).optional()
+});
+var createdApiKeyDtoSchema = apiKeyDtoSchema.extend({
+  key: z4.string()
+});
+
 // ../contracts/src/config-schema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // ../contracts/src/notification.ts
-import { z as z4 } from "zod";
-var notificationEventSchema = z4.enum([
+import { z as z5 } from "zod";
+var notificationEventSchema = z5.enum([
   "citation.lost",
   "citation.gained",
   "run.completed",
@@ -583,76 +611,76 @@ var notificationEventSchema = z4.enum([
   "insight.critical",
   "insight.high"
 ]);
-var notificationDtoSchema = z4.object({
-  id: z4.string(),
-  projectId: z4.string(),
-  channel: z4.literal("webhook"),
-  url: z4.string().url(),
-  urlDisplay: z4.string(),
-  urlHost: z4.string(),
-  events: z4.array(notificationEventSchema),
-  enabled: z4.boolean().default(true),
+var notificationDtoSchema = z5.object({
+  id: z5.string(),
+  projectId: z5.string(),
+  channel: z5.literal("webhook"),
+  url: z5.string().url(),
+  urlDisplay: z5.string(),
+  urlHost: z5.string(),
+  events: z5.array(notificationEventSchema),
+  enabled: z5.boolean().default(true),
   /** Opaque tag identifying the creator (e.g. `"agent"` for Aero webhooks). */
-  source: z4.string().optional(),
-  webhookSecret: z4.string().optional(),
-  createdAt: z4.string(),
-  updatedAt: z4.string()
+  source: z5.string().optional(),
+  webhookSecret: z5.string().optional(),
+  createdAt: z5.string(),
+  updatedAt: z5.string()
 });
-var notificationCreateRequestSchema = z4.object({
-  channel: z4.literal("webhook"),
-  url: z4.string().url(),
-  events: z4.array(notificationEventSchema).min(1),
-  source: z4.string().optional()
+var notificationCreateRequestSchema = z5.object({
+  channel: z5.literal("webhook"),
+  url: z5.string().url(),
+  events: z5.array(notificationEventSchema).min(1),
+  source: z5.string().optional()
 });
 
 // ../contracts/src/config-schema.ts
-var configMetadataSchema = z5.object({
-  name: z5.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, {
+var configMetadataSchema = z6.object({
+  name: z6.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: z5.record(z5.string(), z5.string()).optional().default({})
+  labels: z6.record(z6.string(), z6.string()).optional().default({})
 });
-var configScheduleSchema = z5.object({
-  preset: z5.string().optional(),
-  cron: z5.string().optional(),
-  timezone: z5.string().optional().default("UTC"),
-  providers: z5.array(providerNameSchema).optional().default([])
+var configScheduleSchema = z6.object({
+  preset: z6.string().optional(),
+  cron: z6.string().optional(),
+  timezone: z6.string().optional().default("UTC"),
+  providers: z6.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 = z5.object({
-  channel: z5.literal("webhook"),
-  url: z5.string().url(),
-  events: z5.array(notificationEventSchema).min(1)
-});
-var configGoogleSchema = z5.object({
-  gsc: z5.object({
-    propertyUrl: z5.string()
+var configNotificationSchema = z6.object({
+  channel: z6.literal("webhook"),
+  url: z6.string().url(),
+  events: z6.array(notificationEventSchema).min(1)
+});
+var configGoogleSchema = z6.object({
+  gsc: z6.object({
+    propertyUrl: z6.string()
   }).optional(),
-  syncSchedule: z5.object({
-    preset: z5.string().optional(),
-    cron: z5.string().optional()
+  syncSchedule: z6.object({
+    preset: z6.string().optional(),
+    cron: z6.string().optional()
   }).optional()
 }).optional();
-var configQueryListSchema = z5.array(z5.string().min(1));
-var configSpecSchema = z5.object({
-  displayName: z5.string().min(1),
-  canonicalDomain: z5.string().min(1),
-  ownedDomains: z5.array(z5.string().min(1)).optional().default([]),
-  aliases: z5.array(z5.string().min(1)).optional().default([]),
-  country: z5.string().length(2),
-  language: z5.string().min(2),
+var configQueryListSchema = z6.array(z6.string().min(1));
+var configSpecSchema = z6.object({
+  displayName: z6.string().min(1),
+  canonicalDomain: z6.string().min(1),
+  ownedDomains: z6.array(z6.string().min(1)).optional().default([]),
+  aliases: z6.array(z6.string().min(1)).optional().default([]),
+  country: z6.string().length(2),
+  language: z6.string().min(2),
   queries: configQueryListSchema.optional(),
   keywords: configQueryListSchema.optional(),
-  competitors: z5.array(z5.string().min(1)).optional().default([]),
-  providers: z5.array(providerNameSchema).optional().default([]),
-  locations: z5.array(locationContextSchema).optional().default([]),
-  defaultLocation: z5.string().optional(),
+  competitors: z6.array(z6.string().min(1)).optional().default([]),
+  providers: z6.array(providerNameSchema).optional().default([]),
+  locations: z6.array(locationContextSchema).optional().default([]),
+  defaultLocation: z6.string().optional(),
   schedule: configScheduleSchema,
-  notifications: z5.array(configNotificationSchema).optional().default([]),
+  notifications: z6.array(configNotificationSchema).optional().default([]),
   google: configGoogleSchema,
-  autoExtractBacklinks: z5.boolean().optional().default(false)
+  autoExtractBacklinks: z6.boolean().optional().default(false)
 }).superRefine((spec, ctx) => {
   if (spec.queries !== void 0 && spec.keywords !== void 0) {
     ctx.addIssue({
@@ -677,9 +705,9 @@ var configSpecSchema = z5.object({
     });
   }
 });
-var projectConfigSchema = z5.object({
-  apiVersion: z5.literal("canonry/v1"),
-  kind: z5.literal("Project"),
+var projectConfigSchema = z6.object({
+  apiVersion: z6.literal("canonry/v1"),
+  kind: z6.literal("Project"),
   metadata: configMetadataSchema,
   spec: configSpecSchema
 });
@@ -688,330 +716,330 @@ function resolveConfigSpecQueries(spec) {
 }
 
 // ../contracts/src/google.ts
-import { z as z6 } from "zod";
-var googleConnectionTypeSchema = z6.enum(["gsc", "ga4", "gbp"]);
-var googleConnectionDtoSchema = z6.object({
-  id: z6.string(),
-  domain: z6.string(),
+import { z as z7 } from "zod";
+var googleConnectionTypeSchema = z7.enum(["gsc", "ga4", "gbp"]);
+var googleConnectionDtoSchema = z7.object({
+  id: z7.string(),
+  domain: z7.string(),
   connectionType: googleConnectionTypeSchema,
-  propertyId: z6.string().nullable().optional(),
-  sitemapUrl: z6.string().nullable().optional(),
-  scopes: z6.array(z6.string()).default([]),
-  createdAt: z6.string(),
-  updatedAt: z6.string()
-});
-var gscSearchDataDtoSchema = z6.object({
-  date: z6.string(),
-  query: z6.string(),
-  page: z6.string(),
-  country: z6.string().nullable().optional(),
-  device: z6.string().nullable().optional(),
-  clicks: z6.number(),
-  impressions: z6.number(),
-  ctr: z6.number(),
-  position: z6.number()
-});
-var gscPerformanceDailyPointSchema = z6.object({
-  date: z6.string(),
-  clicks: z6.number(),
-  impressions: z6.number(),
-  ctr: z6.number()
-});
-var gscPerformanceDailyDtoSchema = z6.object({
-  totals: z6.object({
-    clicks: z6.number(),
-    impressions: z6.number(),
-    ctr: z6.number(),
-    days: z6.number()
+  propertyId: z7.string().nullable().optional(),
+  sitemapUrl: z7.string().nullable().optional(),
+  scopes: z7.array(z7.string()).default([]),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
+var gscSearchDataDtoSchema = z7.object({
+  date: z7.string(),
+  query: z7.string(),
+  page: z7.string(),
+  country: z7.string().nullable().optional(),
+  device: z7.string().nullable().optional(),
+  clicks: z7.number(),
+  impressions: z7.number(),
+  ctr: z7.number(),
+  position: z7.number()
+});
+var gscPerformanceDailyPointSchema = z7.object({
+  date: z7.string(),
+  clicks: z7.number(),
+  impressions: z7.number(),
+  ctr: z7.number()
+});
+var gscPerformanceDailyDtoSchema = z7.object({
+  totals: z7.object({
+    clicks: z7.number(),
+    impressions: z7.number(),
+    ctr: z7.number(),
+    days: z7.number()
   }),
-  daily: z6.array(gscPerformanceDailyPointSchema)
-});
-var gscUrlInspectionDtoSchema = z6.object({
-  id: z6.string(),
-  url: z6.string(),
-  indexingState: z6.string().nullable().optional(),
-  verdict: z6.string().nullable().optional(),
-  coverageState: z6.string().nullable().optional(),
-  pageFetchState: z6.string().nullable().optional(),
-  robotsTxtState: z6.string().nullable().optional(),
-  crawlTime: z6.string().nullable().optional(),
-  lastCrawlResult: z6.string().nullable().optional(),
-  isMobileFriendly: z6.boolean().nullable().optional(),
-  richResults: z6.array(z6.string()).default([]),
+  daily: z7.array(gscPerformanceDailyPointSchema)
+});
+var gscUrlInspectionDtoSchema = z7.object({
+  id: z7.string(),
+  url: z7.string(),
+  indexingState: z7.string().nullable().optional(),
+  verdict: z7.string().nullable().optional(),
+  coverageState: z7.string().nullable().optional(),
+  pageFetchState: z7.string().nullable().optional(),
+  robotsTxtState: z7.string().nullable().optional(),
+  crawlTime: z7.string().nullable().optional(),
+  lastCrawlResult: z7.string().nullable().optional(),
+  isMobileFriendly: z7.boolean().nullable().optional(),
+  richResults: z7.array(z7.string()).default([]),
   // Spec gap: server has returned `referringUrls` since the GSC inspect
   // route shipped (see google.ts handler at /gsc/inspect + /gsc/inspections),
   // but the schema dropped the field so the generated TS client (and
   // anything else reading from this DTO) lost the data silently. Adding
   // here restores end-to-end visibility.
-  referringUrls: z6.array(z6.string()).default([]),
-  inspectedAt: z6.string()
-});
-var indexTransitionSchema = z6.enum(["stable", "reindexed", "deindexed", "still-missing", "new"]);
-var gscDeindexedRowSchema = z6.object({
-  url: z6.string(),
-  previousState: z6.string().nullable(),
-  currentState: z6.string().nullable(),
-  transitionDate: z6.string()
-});
-var gscReasonGroupSchema = z6.object({
-  reason: z6.string(),
-  count: z6.number(),
-  urls: z6.array(gscUrlInspectionDtoSchema).default([])
-});
-var gscCoverageSummaryDtoSchema = z6.object({
-  summary: z6.object({
-    total: z6.number(),
-    indexed: z6.number(),
-    notIndexed: z6.number(),
-    deindexed: z6.number(),
-    percentage: z6.number()
+  referringUrls: z7.array(z7.string()).default([]),
+  inspectedAt: z7.string()
+});
+var indexTransitionSchema = z7.enum(["stable", "reindexed", "deindexed", "still-missing", "new"]);
+var gscDeindexedRowSchema = z7.object({
+  url: z7.string(),
+  previousState: z7.string().nullable(),
+  currentState: z7.string().nullable(),
+  transitionDate: z7.string()
+});
+var gscReasonGroupSchema = z7.object({
+  reason: z7.string(),
+  count: z7.number(),
+  urls: z7.array(gscUrlInspectionDtoSchema).default([])
+});
+var gscCoverageSummaryDtoSchema = z7.object({
+  summary: z7.object({
+    total: z7.number(),
+    indexed: z7.number(),
+    notIndexed: z7.number(),
+    deindexed: z7.number(),
+    percentage: z7.number()
   }),
-  lastInspectedAt: z6.string().nullable(),
-  lastSyncedAt: z6.string().nullable(),
-  indexed: z6.array(gscUrlInspectionDtoSchema).default([]),
-  notIndexed: z6.array(gscUrlInspectionDtoSchema).default([]),
-  deindexed: z6.array(gscDeindexedRowSchema).default([]),
-  reasonGroups: z6.array(gscReasonGroupSchema).default([])
-});
-var indexingNotificationDtoSchema = z6.object({
-  url: z6.string(),
-  type: z6.enum(["URL_UPDATED", "URL_DELETED"]),
-  notifiedAt: z6.string()
-});
-var indexingRequestResultDtoSchema = z6.object({
-  url: z6.string(),
-  type: z6.enum(["URL_UPDATED", "URL_DELETED"]),
-  notifiedAt: z6.string(),
-  status: z6.enum(["success", "error"]),
-  error: z6.string().optional()
-});
-var indexingRequestResponseDtoSchema = z6.object({
-  summary: z6.object({
-    total: z6.number().int().nonnegative(),
-    succeeded: z6.number().int().nonnegative(),
-    failed: z6.number().int().nonnegative()
+  lastInspectedAt: z7.string().nullable(),
+  lastSyncedAt: z7.string().nullable(),
+  indexed: z7.array(gscUrlInspectionDtoSchema).default([]),
+  notIndexed: z7.array(gscUrlInspectionDtoSchema).default([]),
+  deindexed: z7.array(gscDeindexedRowSchema).default([]),
+  reasonGroups: z7.array(gscReasonGroupSchema).default([])
+});
+var indexingNotificationDtoSchema = z7.object({
+  url: z7.string(),
+  type: z7.enum(["URL_UPDATED", "URL_DELETED"]),
+  notifiedAt: z7.string()
+});
+var indexingRequestResultDtoSchema = z7.object({
+  url: z7.string(),
+  type: z7.enum(["URL_UPDATED", "URL_DELETED"]),
+  notifiedAt: z7.string(),
+  status: z7.enum(["success", "error"]),
+  error: z7.string().optional()
+});
+var indexingRequestResponseDtoSchema = z7.object({
+  summary: z7.object({
+    total: z7.number().int().nonnegative(),
+    succeeded: z7.number().int().nonnegative(),
+    failed: z7.number().int().nonnegative()
   }),
-  results: z6.array(indexingRequestResultDtoSchema).default([])
-});
-var gscCoverageSnapshotDtoSchema = z6.object({
-  date: z6.string(),
-  indexed: z6.number(),
-  notIndexed: z6.number(),
-  reasonBreakdown: z6.record(z6.string(), z6.number()).default({})
-});
-var gscSiteDtoSchema = z6.object({
-  siteUrl: z6.string(),
-  permissionLevel: z6.string()
-});
-var gscSiteListResponseDtoSchema = z6.object({
-  sites: z6.array(gscSiteDtoSchema).default([])
-});
-var gscSitemapContentDtoSchema = z6.object({
-  type: z6.string(),
-  submitted: z6.string(),
-  indexed: z6.string()
-});
-var gscSitemapDtoSchema = z6.object({
-  path: z6.string(),
-  lastSubmitted: z6.string().optional(),
-  isPending: z6.boolean().optional(),
-  isSitemapsIndex: z6.boolean().optional(),
-  type: z6.string().optional(),
-  lastDownloaded: z6.string().optional(),
-  warnings: z6.string().optional(),
-  errors: z6.string().optional(),
-  contents: z6.array(gscSitemapContentDtoSchema).optional()
-});
-var gscSitemapListResponseDtoSchema = z6.object({
-  sitemaps: z6.array(gscSitemapDtoSchema).default([])
+  results: z7.array(indexingRequestResultDtoSchema).default([])
+});
+var gscCoverageSnapshotDtoSchema = z7.object({
+  date: z7.string(),
+  indexed: z7.number(),
+  notIndexed: z7.number(),
+  reasonBreakdown: z7.record(z7.string(), z7.number()).default({})
+});
+var gscSiteDtoSchema = z7.object({
+  siteUrl: z7.string(),
+  permissionLevel: z7.string()
+});
+var gscSiteListResponseDtoSchema = z7.object({
+  sites: z7.array(gscSiteDtoSchema).default([])
+});
+var gscSitemapContentDtoSchema = z7.object({
+  type: z7.string(),
+  submitted: z7.string(),
+  indexed: z7.string()
+});
+var gscSitemapDtoSchema = z7.object({
+  path: z7.string(),
+  lastSubmitted: z7.string().optional(),
+  isPending: z7.boolean().optional(),
+  isSitemapsIndex: z7.boolean().optional(),
+  type: z7.string().optional(),
+  lastDownloaded: z7.string().optional(),
+  warnings: z7.string().optional(),
+  errors: z7.string().optional(),
+  contents: z7.array(gscSitemapContentDtoSchema).optional()
+});
+var gscSitemapListResponseDtoSchema = z7.object({
+  sitemaps: z7.array(gscSitemapDtoSchema).default([])
 });
 
 // ../contracts/src/gbp.ts
-import { z as z7 } from "zod";
-var gbpAccountDtoSchema = z7.object({
+import { z as z8 } from "zod";
+var gbpAccountDtoSchema = z8.object({
   /** Resource name, "accounts/{n}". */
-  name: z7.string(),
+  name: z8.string(),
   /** Human-readable account name, or null when Google omits it. */
-  accountName: z7.string().nullable(),
+  accountName: z8.string().nullable(),
   /** Account type (PERSONAL, LOCATION_GROUP, ORGANIZATION, …) when present. */
-  type: z7.string().nullable(),
+  type: z8.string().nullable(),
   /** The OAuth user's role on the account (OWNER, MANAGER, …) when present. */
-  role: z7.string().nullable()
+  role: z8.string().nullable()
 });
-var gbpAccountListResponseSchema = z7.object({
-  accounts: z7.array(gbpAccountDtoSchema),
-  total: z7.number().int().nonnegative()
+var gbpAccountListResponseSchema = z8.object({
+  accounts: z8.array(gbpAccountDtoSchema),
+  total: z8.number().int().nonnegative()
 });
-var gbpLocationDtoSchema = z7.object({
-  id: z7.string(),
-  projectId: z7.string(),
-  accountName: z7.string(),
-  locationName: z7.string(),
-  displayName: z7.string(),
-  primaryCategoryDisplayName: z7.string().nullable(),
-  storefrontAddress: z7.string().nullable(),
-  websiteUri: z7.string().nullable(),
+var gbpLocationDtoSchema = z8.object({
+  id: z8.string(),
+  projectId: z8.string(),
+  accountName: z8.string(),
+  locationName: z8.string(),
+  displayName: z8.string(),
+  primaryCategoryDisplayName: z8.string().nullable(),
+  storefrontAddress: z8.string().nullable(),
+  websiteUri: z8.string().nullable(),
   // Google Maps Place ID + public Maps link (from location metadata; null when
   // the location is not on Maps). `placeId` is the join key to the Places API.
-  placeId: z7.string().nullable(),
-  mapsUri: z7.string().nullable(),
-  selected: z7.boolean(),
-  syncedAt: z7.string().nullable(),
-  createdAt: z7.string(),
-  updatedAt: z7.string()
+  placeId: z8.string().nullable(),
+  mapsUri: z8.string().nullable(),
+  selected: z8.boolean(),
+  syncedAt: z8.string().nullable(),
+  createdAt: z8.string(),
+  updatedAt: z8.string()
 });
-var gbpLocationListResponseSchema = z7.object({
-  locations: z7.array(gbpLocationDtoSchema),
-  totalDiscovered: z7.number().int().nonnegative(),
-  totalSelected: z7.number().int().nonnegative()
+var gbpLocationListResponseSchema = z8.object({
+  locations: z8.array(gbpLocationDtoSchema),
+  totalDiscovered: z8.number().int().nonnegative(),
+  totalSelected: z8.number().int().nonnegative()
 });
-var gbpDiscoverRequestSchema = z7.object({
-  selectAllNew: z7.boolean().default(true),
+var gbpDiscoverRequestSchema = z8.object({
+  selectAllNew: z8.boolean().default(true),
   /**
    * Discover locations under this specific account ("accounts/{n}"). Omit to
    * use the account the project already tracks, falling back to the first
    * account the OAuth user can see on the very first discover.
    */
-  accountName: z7.string().optional(),
+  accountName: z8.string().optional(),
   /**
    * Permit replacing the project's locations when `accountName` names a
    * DIFFERENT account than the one currently tracked. Switching is destructive
    * (it clears the old account's locations + synced data), so it must be opted
    * into explicitly — otherwise a mismatched account is rejected.
    */
-  switchAccount: z7.boolean().default(false)
+  switchAccount: z8.boolean().default(false)
 });
-var gbpLocationSelectionRequestSchema = z7.object({
-  selected: z7.boolean()
+var gbpLocationSelectionRequestSchema = z8.object({
+  selected: z8.boolean()
 });
-var gbpSyncRequestSchema = z7.object({
+var gbpSyncRequestSchema = z8.object({
   /** Restrict the sync to specific locations (resource names). Omit = all selected. */
-  locationNames: z7.array(z7.string()).optional(),
-  daysOfMetrics: z7.number().int().positive().max(540).optional(),
-  monthsOfKeywords: z7.number().int().positive().max(18).optional()
+  locationNames: z8.array(z8.string()).optional(),
+  daysOfMetrics: z8.number().int().positive().max(540).optional(),
+  monthsOfKeywords: z8.number().int().positive().max(18).optional()
 });
-var gbpSyncResponseSchema = z7.object({
-  runId: z7.string(),
-  status: z7.string()
+var gbpSyncResponseSchema = z8.object({
+  runId: z8.string(),
+  status: z8.string()
 });
-var gbpDailyMetricDtoSchema = z7.object({
-  locationName: z7.string(),
-  date: z7.string(),
-  metric: z7.string(),
-  value: z7.number().int()
+var gbpDailyMetricDtoSchema = z8.object({
+  locationName: z8.string(),
+  date: z8.string(),
+  metric: z8.string(),
+  value: z8.number().int()
 });
-var gbpDailyMetricListResponseSchema = z7.object({
-  metrics: z7.array(gbpDailyMetricDtoSchema),
-  total: z7.number().int().nonnegative()
+var gbpDailyMetricListResponseSchema = z8.object({
+  metrics: z8.array(gbpDailyMetricDtoSchema),
+  total: z8.number().int().nonnegative()
 });
-var gbpKeywordImpressionDtoSchema = z7.object({
-  locationName: z7.string(),
+var gbpKeywordImpressionDtoSchema = z8.object({
+  locationName: z8.string(),
   // The Performance API returns one impressions figure per keyword aggregated
   // over the whole requested range — it does NOT break the count down by month.
   // `periodStart`/`periodEnd` (both YYYY-MM, inclusive) record that trailing
   // window so the figure is never mistaken for a single calendar month.
-  periodStart: z7.string(),
-  periodEnd: z7.string(),
-  keyword: z7.string(),
+  periodStart: z8.string(),
+  periodEnd: z8.string(),
+  keyword: z8.string(),
   /** Exact impressions over [periodStart, periodEnd], or null when Google redacted to a threshold. */
-  valueCount: z7.number().int().nullable(),
+  valueCount: z8.number().int().nullable(),
   /** Privacy floor, or null when an exact value is available. */
-  valueThreshold: z7.number().int().nullable()
+  valueThreshold: z8.number().int().nullable()
 });
-var gbpKeywordImpressionListResponseSchema = z7.object({
-  keywords: z7.array(gbpKeywordImpressionDtoSchema),
-  total: z7.number().int().nonnegative(),
+var gbpKeywordImpressionListResponseSchema = z8.object({
+  keywords: z8.array(gbpKeywordImpressionDtoSchema),
+  total: z8.number().int().nonnegative(),
   /** Share of returned keywords that are privacy-thresholded (0–100, rounded). */
-  thresholdedPct: z7.number().int().min(0).max(100)
-});
-var gbpPlaceActionDtoSchema = z7.object({
-  locationName: z7.string(),
-  placeActionLinkName: z7.string(),
-  placeActionType: z7.string(),
-  uri: z7.string().nullable(),
-  isPreferred: z7.boolean(),
-  providerType: z7.string().nullable()
-});
-var gbpPlaceActionListResponseSchema = z7.object({
-  placeActions: z7.array(gbpPlaceActionDtoSchema),
-  total: z7.number().int().nonnegative()
-});
-var gbpLodgingDtoSchema = z7.object({
-  locationName: z7.string(),
+  thresholdedPct: z8.number().int().min(0).max(100)
+});
+var gbpPlaceActionDtoSchema = z8.object({
+  locationName: z8.string(),
+  placeActionLinkName: z8.string(),
+  placeActionType: z8.string(),
+  uri: z8.string().nullable(),
+  isPreferred: z8.boolean(),
+  providerType: z8.string().nullable()
+});
+var gbpPlaceActionListResponseSchema = z8.object({
+  placeActions: z8.array(gbpPlaceActionDtoSchema),
+  total: z8.number().int().nonnegative()
+});
+var gbpLodgingDtoSchema = z8.object({
+  locationName: z8.string(),
   /** Count of non-empty top-level attribute groups (0 = empty profile / AEO gap). */
-  populatedGroupCount: z7.number().int().nonnegative(),
-  syncedAt: z7.string(),
+  populatedGroupCount: z8.number().int().nonnegative(),
+  syncedAt: z8.string(),
   /** Raw Lodging resource as Google returned it. */
-  attributes: z7.record(z7.string(), z7.unknown())
+  attributes: z8.record(z8.string(), z8.unknown())
 });
-var gbpLodgingListResponseSchema = z7.object({
-  lodging: z7.array(gbpLodgingDtoSchema),
-  total: z7.number().int().nonnegative()
+var gbpLodgingListResponseSchema = z8.object({
+  lodging: z8.array(gbpLodgingDtoSchema),
+  total: z8.number().int().nonnegative()
 });
-var gbpPlaceDetailsDtoSchema = z7.object({
-  locationName: z7.string(),
-  placeId: z7.string(),
+var gbpPlaceDetailsDtoSchema = z8.object({
+  locationName: z8.string(),
+  placeId: z8.string(),
   /** Field-mask SKU tier the snapshot was fetched at ('atmosphere' | 'pro'). */
-  tier: z7.string(),
+  tier: z8.string(),
   /** Amenities the public listing advertises, derived from `place`. */
-  amenities: z7.array(z7.string()),
+  amenities: z8.array(z8.string()),
   /** When this listing was last fetched from Places — advances on every fetch, even when the content is unchanged (this is what the refresh-cadence gate reads). */
-  syncedAt: z7.string(),
+  syncedAt: z8.string(),
   /** Raw Place Details resource as Google returned it. */
-  place: z7.record(z7.string(), z7.unknown())
+  place: z8.record(z8.string(), z8.unknown())
 });
-var gbpPlaceDetailsListResponseSchema = z7.object({
-  places: z7.array(gbpPlaceDetailsDtoSchema),
-  total: z7.number().int().nonnegative()
+var gbpPlaceDetailsListResponseSchema = z8.object({
+  places: z8.array(gbpPlaceDetailsDtoSchema),
+  total: z8.number().int().nonnegative()
 });
-var gbpSummaryDtoSchema = z7.object({
-  scope: z7.object({
-    locationName: z7.string().nullable(),
-    locationCount: z7.number().int().nonnegative()
+var gbpSummaryDtoSchema = z8.object({
+  scope: z8.object({
+    locationName: z8.string().nullable(),
+    locationCount: z8.number().int().nonnegative()
   }),
-  performance: z7.object({
-    totals: z7.record(z7.string(), z7.number()),
-    recent7d: z7.record(z7.string(), z7.number()),
-    prior7d: z7.record(z7.string(), z7.number()),
+  performance: z8.object({
+    totals: z8.record(z8.string(), z8.number()),
+    recent7d: z8.record(z8.string(), z8.number()),
+    prior7d: z8.record(z8.string(), z8.number()),
     // Per-metric % change recent-vs-prior, computed over COMPLETE days only
     // (the windows anchor to `freshness.dataThroughDate`, never the lagging
     // tail), so a reporting-lag artifact is never shown as a real delta.
-    deltaPct: z7.record(z7.string(), z7.number().nullable())
+    deltaPct: z8.record(z8.string(), z8.number().nullable())
   }),
   // GBP Performance data lags a few days; the most recent stored days can be
   // not-yet-reported zeros. `freshness` lets every renderer mark the trailing
   // window as pending instead of treating it as a real decline.
-  freshness: z7.object({
+  freshness: z8.object({
     /** Latest day with reported (non-zero) activity — the last complete day. Null when there's no data. */
-    dataThroughDate: z7.string().nullable(),
+    dataThroughDate: z8.string().nullable(),
     /** Max stored metric date (>= dataThroughDate when Google has emitted not-yet-final zero rows). Null when there's no data. */
-    latestStoredDate: z7.string().nullable(),
+    latestStoredDate: z8.string().nullable(),
     /** Calendar days between dataThroughDate and the as-of date — the trailing window still pending/unreported. */
-    pendingDays: z7.number().int().nonnegative()
+    pendingDays: z8.number().int().nonnegative()
   }),
   // Daily series (most recent ~30 days) for the trend charts. Each day carries
   // every metric present in the window (0 where a metric had no row that day),
   // and a `pending` flag so the lag tail renders distinct, never as zeros.
-  timeseries: z7.array(z7.object({
-    date: z7.string(),
-    pending: z7.boolean(),
-    metrics: z7.record(z7.string(), z7.number())
+  timeseries: z8.array(z8.object({
+    date: z8.string(),
+    pending: z8.boolean(),
+    metrics: z8.record(z8.string(), z8.number())
   })),
-  keywords: z7.object({
-    total: z7.number().int().nonnegative(),
-    thresholdedCount: z7.number().int().nonnegative(),
-    thresholdedPct: z7.number().int().min(0).max(100)
+  keywords: z8.object({
+    total: z8.number().int().nonnegative(),
+    thresholdedCount: z8.number().int().nonnegative(),
+    thresholdedPct: z8.number().int().min(0).max(100)
   }),
-  placeActions: z7.object({
-    total: z7.number().int().nonnegative(),
-    hasReservationCta: z7.boolean(),
-    hasBookingCta: z7.boolean(),
-    hasDirectMerchantCta: z7.boolean()
+  placeActions: z8.object({
+    total: z8.number().int().nonnegative(),
+    hasReservationCta: z8.boolean(),
+    hasBookingCta: z8.boolean(),
+    hasDirectMerchantCta: z8.boolean()
   }),
-  lodging: z7.object({
-    lodgingLocationCount: z7.number().int().nonnegative(),
-    populatedLodgingCount: z7.number().int().nonnegative(),
-    emptyLodgingCount: z7.number().int().nonnegative()
+  lodging: z8.object({
+    lodgingLocationCount: z8.number().int().nonnegative(),
+    populatedLodgingCount: z8.number().int().nonnegative(),
+    emptyLodgingCount: z8.number().int().nonnegative()
   })
 });
 var GBP_METRIC_LABELS = {
@@ -1086,251 +1114,251 @@ function isRetryableHttpError(err) {
 }
 
 // ../contracts/src/bing.ts
-import { z as z8 } from "zod";
-var bingConnectionDtoSchema = z8.object({
-  id: z8.string(),
-  domain: z8.string(),
-  siteUrl: z8.string().nullable().optional(),
-  createdAt: z8.string(),
-  updatedAt: z8.string()
-});
-var bingUrlInspectionDtoSchema = z8.object({
-  id: z8.string(),
-  url: z8.string(),
-  httpCode: z8.number().nullable().optional(),
-  inIndex: z8.boolean().nullable().optional(),
-  lastCrawledDate: z8.string().nullable().optional(),
-  inIndexDate: z8.string().nullable().optional(),
-  inspectedAt: z8.string(),
+import { z as z9 } from "zod";
+var bingConnectionDtoSchema = z9.object({
+  id: z9.string(),
+  domain: z9.string(),
+  siteUrl: z9.string().nullable().optional(),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
+});
+var bingUrlInspectionDtoSchema = z9.object({
+  id: z9.string(),
+  url: z9.string(),
+  httpCode: z9.number().nullable().optional(),
+  inIndex: z9.boolean().nullable().optional(),
+  lastCrawledDate: z9.string().nullable().optional(),
+  inIndexDate: z9.string().nullable().optional(),
+  inspectedAt: z9.string(),
   // Fields derived from GetUrlInfo response (more reliable than InIndex)
-  documentSize: z8.number().nullable().optional(),
-  anchorCount: z8.number().nullable().optional(),
-  discoveryDate: z8.string().nullable().optional()
-});
-var bingCoverageSummaryDtoSchema = z8.object({
-  summary: z8.object({
-    total: z8.number(),
-    indexed: z8.number(),
-    notIndexed: z8.number(),
-    unknown: z8.number().optional(),
-    percentage: z8.number()
+  documentSize: z9.number().nullable().optional(),
+  anchorCount: z9.number().nullable().optional(),
+  discoveryDate: z9.string().nullable().optional()
+});
+var bingCoverageSummaryDtoSchema = z9.object({
+  summary: z9.object({
+    total: z9.number(),
+    indexed: z9.number(),
+    notIndexed: z9.number(),
+    unknown: z9.number().optional(),
+    percentage: z9.number()
   }),
-  lastInspectedAt: z8.string().nullable(),
-  indexed: z8.array(bingUrlInspectionDtoSchema).default([]),
-  notIndexed: z8.array(bingUrlInspectionDtoSchema).default([]),
-  unknown: z8.array(bingUrlInspectionDtoSchema).default([]).optional()
-});
-var bingKeywordStatsDtoSchema = z8.object({
-  query: z8.string(),
-  impressions: z8.number(),
-  clicks: z8.number(),
-  ctr: z8.number(),
-  averagePosition: z8.number()
-});
-var bingCoverageSnapshotDtoSchema = z8.object({
-  date: z8.string(),
-  indexed: z8.number(),
-  notIndexed: z8.number(),
-  unknown: z8.number()
-});
-var bingSubmitResultDtoSchema = z8.object({
-  url: z8.string(),
-  status: z8.enum(["success", "error"]),
-  submittedAt: z8.string(),
-  error: z8.string().optional()
-});
-var bingIndexingRequestResponseDtoSchema = z8.object({
-  summary: z8.object({
-    total: z8.number().int().nonnegative(),
-    succeeded: z8.number().int().nonnegative(),
-    failed: z8.number().int().nonnegative()
+  lastInspectedAt: z9.string().nullable(),
+  indexed: z9.array(bingUrlInspectionDtoSchema).default([]),
+  notIndexed: z9.array(bingUrlInspectionDtoSchema).default([]),
+  unknown: z9.array(bingUrlInspectionDtoSchema).default([]).optional()
+});
+var bingKeywordStatsDtoSchema = z9.object({
+  query: z9.string(),
+  impressions: z9.number(),
+  clicks: z9.number(),
+  ctr: z9.number(),
+  averagePosition: z9.number()
+});
+var bingCoverageSnapshotDtoSchema = z9.object({
+  date: z9.string(),
+  indexed: z9.number(),
+  notIndexed: z9.number(),
+  unknown: z9.number()
+});
+var bingSubmitResultDtoSchema = z9.object({
+  url: z9.string(),
+  status: z9.enum(["success", "error"]),
+  submittedAt: z9.string(),
+  error: z9.string().optional()
+});
+var bingIndexingRequestResponseDtoSchema = z9.object({
+  summary: z9.object({
+    total: z9.number().int().nonnegative(),
+    succeeded: z9.number().int().nonnegative(),
+    failed: z9.number().int().nonnegative()
   }),
-  results: z8.array(bingSubmitResultDtoSchema).default([])
+  results: z9.array(bingSubmitResultDtoSchema).default([])
 });
-var bingSiteDtoSchema = z8.object({
-  url: z8.string(),
-  verified: z8.boolean()
+var bingSiteDtoSchema = z9.object({
+  url: z9.string(),
+  verified: z9.boolean()
 });
-var bingSitesResponseDtoSchema = z8.object({
-  sites: z8.array(bingSiteDtoSchema).default([])
+var bingSitesResponseDtoSchema = z9.object({
+  sites: z9.array(bingSiteDtoSchema).default([])
 });
-var bingStatusDtoSchema = z8.object({
-  connected: z8.boolean(),
-  domain: z8.string(),
-  siteUrl: z8.string().nullable(),
-  createdAt: z8.string().nullable(),
-  updatedAt: z8.string().nullable()
+var bingStatusDtoSchema = z9.object({
+  connected: z9.boolean(),
+  domain: z9.string(),
+  siteUrl: z9.string().nullable(),
+  createdAt: z9.string().nullable(),
+  updatedAt: z9.string().nullable()
 });
-var bingConnectResponseDtoSchema = z8.object({
-  connected: z8.boolean(),
-  domain: z8.string(),
-  siteUrl: z8.string().nullable(),
-  availableSites: z8.array(bingSiteDtoSchema).default([])
+var bingConnectResponseDtoSchema = z9.object({
+  connected: z9.boolean(),
+  domain: z9.string(),
+  siteUrl: z9.string().nullable(),
+  availableSites: z9.array(bingSiteDtoSchema).default([])
 });
-var bingSetSiteResponseDtoSchema = z8.object({
-  siteUrl: z8.string()
+var bingSetSiteResponseDtoSchema = z9.object({
+  siteUrl: z9.string()
 });
 
 // ../contracts/src/cdp.ts
-import { z as z9 } from "zod";
-var cdpTargetStatusDtoSchema = z9.object({
-  name: z9.string(),
-  alive: z9.boolean(),
-  lastUsed: z9.string().nullable()
+import { z as z10 } from "zod";
+var cdpTargetStatusDtoSchema = z10.object({
+  name: z10.string(),
+  alive: z10.boolean(),
+  lastUsed: z10.string().nullable()
 });
-var cdpStatusDtoSchema = z9.object({
-  connected: z9.boolean(),
-  endpoint: z9.string(),
-  version: z9.string().optional(),
-  browserVersion: z9.string().optional(),
-  targets: z9.array(cdpTargetStatusDtoSchema).default([])
+var cdpStatusDtoSchema = z10.object({
+  connected: z10.boolean(),
+  endpoint: z10.string(),
+  version: z10.string().optional(),
+  browserVersion: z10.string().optional(),
+  targets: z10.array(cdpTargetStatusDtoSchema).default([])
 });
 
 // ../contracts/src/wordpress.ts
-import { z as z10 } from "zod";
-var wordpressEnvSchema = z10.enum(["live", "staging"]);
-var wordpressConnectionDtoSchema = z10.object({
-  projectName: z10.string(),
-  url: z10.string(),
-  stagingUrl: z10.string().optional(),
-  username: z10.string(),
+import { z as z11 } from "zod";
+var wordpressEnvSchema = z11.enum(["live", "staging"]);
+var wordpressConnectionDtoSchema = z11.object({
+  projectName: z11.string(),
+  url: z11.string(),
+  stagingUrl: z11.string().optional(),
+  username: z11.string(),
   defaultEnv: wordpressEnvSchema,
-  createdAt: z10.string(),
-  updatedAt: z10.string()
-});
-var wordpressSiteStatusDtoSchema = z10.object({
-  url: z10.string(),
-  reachable: z10.boolean(),
-  pageCount: z10.number().nullable().optional(),
-  version: z10.string().nullable().optional(),
-  error: z10.string().nullable().optional(),
-  plugins: z10.array(z10.string()).optional(),
-  authenticatedUser: z10.object({
-    id: z10.number(),
-    slug: z10.string()
+  createdAt: z11.string(),
+  updatedAt: z11.string()
+});
+var wordpressSiteStatusDtoSchema = z11.object({
+  url: z11.string(),
+  reachable: z11.boolean(),
+  pageCount: z11.number().nullable().optional(),
+  version: z11.string().nullable().optional(),
+  error: z11.string().nullable().optional(),
+  plugins: z11.array(z11.string()).optional(),
+  authenticatedUser: z11.object({
+    id: z11.number(),
+    slug: z11.string()
   }).nullable().optional()
 });
-var wordpressStatusDtoSchema = z10.object({
-  connected: z10.boolean(),
-  projectName: z10.string(),
+var wordpressStatusDtoSchema = z11.object({
+  connected: z11.boolean(),
+  projectName: z11.string(),
   defaultEnv: wordpressEnvSchema,
   live: wordpressSiteStatusDtoSchema.nullable(),
   staging: wordpressSiteStatusDtoSchema.nullable(),
-  adminUrl: z10.string().nullable().optional()
-});
-var wordpressPageSummaryDtoSchema = z10.object({
-  id: z10.number(),
-  slug: z10.string(),
-  title: z10.string(),
-  status: z10.string(),
-  modifiedAt: z10.string().nullable().optional(),
-  link: z10.string().nullable().optional()
-});
-var wordpressSeoStateDtoSchema = z10.object({
-  title: z10.string().nullable(),
-  description: z10.string().nullable(),
-  noindex: z10.boolean().nullable(),
-  writable: z10.boolean().default(false),
-  writeTargets: z10.array(z10.string()).default([])
-});
-var wordpressSchemaBlockDtoSchema = z10.object({
-  type: z10.string(),
-  json: z10.record(z10.string(), z10.unknown())
+  adminUrl: z11.string().nullable().optional()
+});
+var wordpressPageSummaryDtoSchema = z11.object({
+  id: z11.number(),
+  slug: z11.string(),
+  title: z11.string(),
+  status: z11.string(),
+  modifiedAt: z11.string().nullable().optional(),
+  link: z11.string().nullable().optional()
+});
+var wordpressSeoStateDtoSchema = z11.object({
+  title: z11.string().nullable(),
+  description: z11.string().nullable(),
+  noindex: z11.boolean().nullable(),
+  writable: z11.boolean().default(false),
+  writeTargets: z11.array(z11.string()).default([])
+});
+var wordpressSchemaBlockDtoSchema = z11.object({
+  type: z11.string(),
+  json: z11.record(z11.string(), z11.unknown())
 });
 var wordpressPageDetailDtoSchema = wordpressPageSummaryDtoSchema.extend({
   env: wordpressEnvSchema,
-  content: z10.string(),
+  content: z11.string(),
   seo: wordpressSeoStateDtoSchema,
-  schemaBlocks: z10.array(wordpressSchemaBlockDtoSchema).default([])
+  schemaBlocks: z11.array(wordpressSchemaBlockDtoSchema).default([])
 });
 var wordpressDiffPageDtoSchema = wordpressPageDetailDtoSchema.extend({
-  contentHash: z10.string(),
-  contentSnippet: z10.string()
-});
-var wordpressManualAssistDtoSchema = z10.object({
-  manualRequired: z10.literal(true),
-  targetUrl: z10.string(),
-  adminUrl: z10.string().nullable().optional(),
-  content: z10.string(),
-  nextSteps: z10.array(z10.string()).default([])
-});
-var wordpressAuditIssueDtoSchema = z10.object({
-  slug: z10.string(),
-  severity: z10.enum(["high", "medium", "low"]),
-  code: z10.enum([
+  contentHash: z11.string(),
+  contentSnippet: z11.string()
+});
+var wordpressManualAssistDtoSchema = z11.object({
+  manualRequired: z11.literal(true),
+  targetUrl: z11.string(),
+  adminUrl: z11.string().nullable().optional(),
+  content: z11.string(),
+  nextSteps: z11.array(z11.string()).default([])
+});
+var wordpressAuditIssueDtoSchema = z11.object({
+  slug: z11.string(),
+  severity: z11.enum(["high", "medium", "low"]),
+  code: z11.enum([
     "noindex",
     "missing-seo-title",
     "missing-meta-description",
     "missing-schema",
     "thin-content"
   ]),
-  message: z10.string()
+  message: z11.string()
 });
-var wordpressAuditPageDtoSchema = z10.object({
-  slug: z10.string(),
-  title: z10.string(),
-  status: z10.string(),
-  wordCount: z10.number(),
+var wordpressAuditPageDtoSchema = z11.object({
+  slug: z11.string(),
+  title: z11.string(),
+  status: z11.string(),
+  wordCount: z11.number(),
   seo: wordpressSeoStateDtoSchema,
-  schemaPresent: z10.boolean(),
-  issues: z10.array(wordpressAuditIssueDtoSchema).default([])
+  schemaPresent: z11.boolean(),
+  issues: z11.array(wordpressAuditIssueDtoSchema).default([])
 });
-var wordpressBulkMetaEntryResultDtoSchema = z10.object({
-  slug: z10.string(),
-  status: z10.enum(["applied", "skipped", "manual"]),
-  error: z10.string().optional(),
+var wordpressBulkMetaEntryResultDtoSchema = z11.object({
+  slug: z11.string(),
+  status: z11.enum(["applied", "skipped", "manual"]),
+  error: z11.string().optional(),
   manualAssist: wordpressManualAssistDtoSchema.optional()
 });
-var wordpressBulkMetaResultDtoSchema = z10.object({
+var wordpressBulkMetaResultDtoSchema = z11.object({
   env: wordpressEnvSchema,
-  strategy: z10.enum(["plugin", "manual"]),
-  results: z10.array(wordpressBulkMetaEntryResultDtoSchema)
+  strategy: z11.enum(["plugin", "manual"]),
+  results: z11.array(wordpressBulkMetaEntryResultDtoSchema)
 });
-var wordpressSchemaDeployEntryResultDtoSchema = z10.object({
-  slug: z10.string(),
-  status: z10.enum(["deployed", "stripped", "skipped", "failed"]),
-  schemasInjected: z10.array(z10.string()).optional(),
+var wordpressSchemaDeployEntryResultDtoSchema = z11.object({
+  slug: z11.string(),
+  status: z11.enum(["deployed", "stripped", "skipped", "failed"]),
+  schemasInjected: z11.array(z11.string()).optional(),
   manualAssist: wordpressManualAssistDtoSchema.optional(),
-  error: z10.string().optional()
+  error: z11.string().optional()
 });
-var wordpressSchemaDeployResultDtoSchema = z10.object({
+var wordpressSchemaDeployResultDtoSchema = z11.object({
   env: wordpressEnvSchema,
-  results: z10.array(wordpressSchemaDeployEntryResultDtoSchema)
+  results: z11.array(wordpressSchemaDeployEntryResultDtoSchema)
 });
-var wordpressSchemaStatusPageDtoSchema = z10.object({
-  slug: z10.string(),
-  title: z10.string(),
-  canonrySchemas: z10.array(z10.string()),
-  thirdPartySchemas: z10.array(z10.string()),
-  hasCanonrySchema: z10.boolean()
+var wordpressSchemaStatusPageDtoSchema = z11.object({
+  slug: z11.string(),
+  title: z11.string(),
+  canonrySchemas: z11.array(z11.string()),
+  thirdPartySchemas: z11.array(z11.string()),
+  hasCanonrySchema: z11.boolean()
 });
-var wordpressSchemaStatusResultDtoSchema = z10.object({
+var wordpressSchemaStatusResultDtoSchema = z11.object({
   env: wordpressEnvSchema,
-  pages: z10.array(wordpressSchemaStatusPageDtoSchema)
+  pages: z11.array(wordpressSchemaStatusPageDtoSchema)
 });
-var wordpressOnboardStepDtoSchema = z10.object({
-  name: z10.string(),
-  status: z10.enum(["completed", "skipped", "failed"]),
-  summary: z10.string().optional(),
-  error: z10.string().optional()
+var wordpressOnboardStepDtoSchema = z11.object({
+  name: z11.string(),
+  status: z11.enum(["completed", "skipped", "failed"]),
+  summary: z11.string().optional(),
+  error: z11.string().optional()
 });
-var wordpressOnboardResultDtoSchema = z10.object({
-  projectName: z10.string(),
-  steps: z10.array(wordpressOnboardStepDtoSchema)
+var wordpressOnboardResultDtoSchema = z11.object({
+  projectName: z11.string(),
+  steps: z11.array(wordpressOnboardStepDtoSchema)
 });
-var wordpressDiffDtoSchema = z10.object({
-  slug: z10.string(),
+var wordpressDiffDtoSchema = z11.object({
+  slug: z11.string(),
   live: wordpressDiffPageDtoSchema,
   staging: wordpressDiffPageDtoSchema,
-  hasDifferences: z10.boolean(),
-  differences: z10.object({
-    title: z10.boolean(),
-    slug: z10.boolean(),
-    content: z10.boolean(),
-    seoTitle: z10.boolean(),
-    seoDescription: z10.boolean(),
-    noindex: z10.boolean(),
-    schema: z10.boolean()
+  hasDifferences: z11.boolean(),
+  differences: z11.object({
+    title: z11.boolean(),
+    slug: z11.boolean(),
+    content: z11.boolean(),
+    seoTitle: z11.boolean(),
+    seoDescription: z11.boolean(),
+    noindex: z11.boolean(),
+    schema: z11.boolean()
   })
 });
 
@@ -1372,42 +1400,42 @@ var LlmCapabilities = {
 var LLM_CAPABILITIES = Object.values(LlmCapabilities);
 
 // ../contracts/src/settings.ts
-import { z as z11 } from "zod";
-var providerSummaryEntryDtoSchema = z11.object({
-  name: z11.string(),
-  displayName: z11.string().optional(),
-  keyUrl: z11.string().optional(),
-  modelHint: z11.string().optional(),
-  model: z11.string().optional(),
+import { z as z12 } from "zod";
+var providerSummaryEntryDtoSchema = z12.object({
+  name: z12.string(),
+  displayName: z12.string().optional(),
+  keyUrl: z12.string().optional(),
+  modelHint: z12.string().optional(),
+  model: z12.string().optional(),
   /**
    * The adapter's built-in default model. Surfaced so the UI and CLI can show
    * the effective model even when no explicit `model` override is configured.
    */
-  defaultModel: z11.string().optional(),
-  configured: z11.boolean(),
+  defaultModel: z12.string().optional(),
+  configured: z12.boolean(),
   quota: providerQuotaPolicySchema.optional(),
   /** Whether Vertex AI is configured for this provider (Gemini only). */
-  vertexConfigured: z11.boolean().optional()
+  vertexConfigured: z12.boolean().optional()
 });
-var integrationSettingsSummaryDtoSchema = z11.object({
-  configured: z11.boolean()
+var integrationSettingsSummaryDtoSchema = z12.object({
+  configured: z12.boolean()
 });
-var settingsDtoSchema = z11.object({
-  providers: z11.array(providerSummaryEntryDtoSchema).default([]),
+var settingsDtoSchema = z12.object({
+  providers: z12.array(providerSummaryEntryDtoSchema).default([]),
   google: integrationSettingsSummaryDtoSchema,
   bing: integrationSettingsSummaryDtoSchema
 });
 
 // ../contracts/src/snapshot.ts
-import { z as z12 } from "zod";
-var snapshotAccuracySchema = z12.enum(["yes", "no", "unknown", "not-mentioned"]);
-var snapshotQueryListSchema = z12.array(z12.string().min(1));
-var snapshotRequestSchema = z12.object({
-  companyName: z12.string().min(1),
-  domain: z12.string().min(1),
+import { z as z13 } from "zod";
+var snapshotAccuracySchema = z13.enum(["yes", "no", "unknown", "not-mentioned"]);
+var snapshotQueryListSchema = z13.array(z13.string().min(1));
+var snapshotRequestSchema = z13.object({
+  companyName: z13.string().min(1),
+  domain: z13.string().min(1),
   queries: snapshotQueryListSchema.optional(),
   phrases: snapshotQueryListSchema.optional(),
-  competitors: z12.array(z12.string().min(1)).optional().default([])
+  competitors: z13.array(z13.string().min(1)).optional().default([])
 }).superRefine((input, ctx) => {
   if (input.queries !== void 0 && input.phrases !== void 0) {
     ctx.addIssue({
@@ -1420,155 +1448,155 @@ var snapshotRequestSchema = z12.object({
 function resolveSnapshotRequestQueries(input) {
   return input.queries ?? input.phrases ?? [];
 }
-var snapshotCompetitorEntrySchema = z12.object({
-  name: z12.string(),
-  count: z12.number().int().nonnegative()
+var snapshotCompetitorEntrySchema = z13.object({
+  name: z13.string(),
+  count: z13.number().int().nonnegative()
 });
-var snapshotAuditFactorSchema = z12.object({
-  id: z12.string(),
-  name: z12.string(),
-  weight: z12.number(),
-  score: z12.number(),
-  grade: z12.string(),
-  status: z12.enum(["pass", "partial", "fail"]),
-  findings: z12.array(z12.object({
-    type: z12.string(),
-    message: z12.string()
+var snapshotAuditFactorSchema = z13.object({
+  id: z13.string(),
+  name: z13.string(),
+  weight: z13.number(),
+  score: z13.number(),
+  grade: z13.string(),
+  status: z13.enum(["pass", "partial", "fail"]),
+  findings: z13.array(z13.object({
+    type: z13.string(),
+    message: z13.string()
   })).default([]),
-  recommendations: z12.array(z12.string()).default([])
-});
-var snapshotAuditSchema = z12.object({
-  url: z12.string(),
-  finalUrl: z12.string(),
-  auditedAt: z12.string(),
-  overallScore: z12.number(),
-  overallGrade: z12.string(),
-  summary: z12.string(),
-  factors: z12.array(snapshotAuditFactorSchema).default([])
-});
-var snapshotProfileSchema = z12.object({
-  industry: z12.string(),
-  summary: z12.string(),
-  services: z12.array(z12.string()).default([]),
-  categoryTerms: z12.array(z12.string()).default([])
-});
-var snapshotProviderResultSchema = z12.object({
-  provider: z12.string(),
-  displayName: z12.string(),
-  model: z12.string().nullable().optional(),
-  mentioned: z12.boolean(),
-  cited: z12.boolean(),
+  recommendations: z13.array(z13.string()).default([])
+});
+var snapshotAuditSchema = z13.object({
+  url: z13.string(),
+  finalUrl: z13.string(),
+  auditedAt: z13.string(),
+  overallScore: z13.number(),
+  overallGrade: z13.string(),
+  summary: z13.string(),
+  factors: z13.array(snapshotAuditFactorSchema).default([])
+});
+var snapshotProfileSchema = z13.object({
+  industry: z13.string(),
+  summary: z13.string(),
+  services: z13.array(z13.string()).default([]),
+  categoryTerms: z13.array(z13.string()).default([])
+});
+var snapshotProviderResultSchema = z13.object({
+  provider: z13.string(),
+  displayName: z13.string(),
+  model: z13.string().nullable().optional(),
+  mentioned: z13.boolean(),
+  cited: z13.boolean(),
   describedAccurately: snapshotAccuracySchema,
-  accuracyNotes: z12.string().nullable().optional(),
-  incorrectClaims: z12.array(z12.string()).default([]),
-  recommendedCompetitors: z12.array(z12.string()).default([]),
-  citedDomains: z12.array(z12.string()).default([]),
-  groundingSources: z12.array(groundingSourceSchema).default([]),
-  searchQueries: z12.array(z12.string()).default([]),
-  answerText: z12.string(),
-  error: z12.string().nullable().optional()
-});
-var snapshotQueryResultSchema = z12.object({
-  query: z12.string(),
-  providerResults: z12.array(snapshotProviderResultSchema).default([])
-});
-var snapshotSummarySchema = z12.object({
-  totalQueries: z12.number().int().nonnegative(),
-  totalProviders: z12.number().int().nonnegative(),
-  totalComparisons: z12.number().int().nonnegative(),
-  mentionCount: z12.number().int().nonnegative(),
-  citationCount: z12.number().int().nonnegative(),
-  topCompetitors: z12.array(snapshotCompetitorEntrySchema).default([]),
-  visibilityGap: z12.string(),
-  whatThisMeans: z12.array(z12.string()).default([]),
-  recommendedActions: z12.array(z12.string()).default([])
-});
-var snapshotReportSchema = z12.object({
-  companyName: z12.string(),
-  domain: z12.string(),
-  homepageUrl: z12.string(),
-  generatedAt: z12.string(),
-  queries: z12.array(z12.string()).default([]),
-  competitors: z12.array(z12.string()).default([]),
+  accuracyNotes: z13.string().nullable().optional(),
+  incorrectClaims: z13.array(z13.string()).default([]),
+  recommendedCompetitors: z13.array(z13.string()).default([]),
+  citedDomains: z13.array(z13.string()).default([]),
+  groundingSources: z13.array(groundingSourceSchema).default([]),
+  searchQueries: z13.array(z13.string()).default([]),
+  answerText: z13.string(),
+  error: z13.string().nullable().optional()
+});
+var snapshotQueryResultSchema = z13.object({
+  query: z13.string(),
+  providerResults: z13.array(snapshotProviderResultSchema).default([])
+});
+var snapshotSummarySchema = z13.object({
+  totalQueries: z13.number().int().nonnegative(),
+  totalProviders: z13.number().int().nonnegative(),
+  totalComparisons: z13.number().int().nonnegative(),
+  mentionCount: z13.number().int().nonnegative(),
+  citationCount: z13.number().int().nonnegative(),
+  topCompetitors: z13.array(snapshotCompetitorEntrySchema).default([]),
+  visibilityGap: z13.string(),
+  whatThisMeans: z13.array(z13.string()).default([]),
+  recommendedActions: z13.array(z13.string()).default([])
+});
+var snapshotReportSchema = z13.object({
+  companyName: z13.string(),
+  domain: z13.string(),
+  homepageUrl: z13.string(),
+  generatedAt: z13.string(),
+  queries: z13.array(z13.string()).default([]),
+  competitors: z13.array(z13.string()).default([]),
   profile: snapshotProfileSchema,
   audit: snapshotAuditSchema,
-  queryResults: z12.array(snapshotQueryResultSchema).default([]),
+  queryResults: z13.array(snapshotQueryResultSchema).default([]),
   summary: snapshotSummarySchema
 });
 
 // ../contracts/src/schedule.ts
-import { z as z13 } from "zod";
-var schedulableRunKindSchema = z13.enum(["answer-visibility", "traffic-sync", "gbp-sync", "data-refresh", "backlinks-sync"]);
+import { z as z14 } from "zod";
+var schedulableRunKindSchema = z14.enum(["answer-visibility", "traffic-sync", "gbp-sync", "data-refresh", "backlinks-sync"]);
 var SchedulableRunKinds = schedulableRunKindSchema.enum;
-var scheduleDtoSchema = z13.object({
-  id: z13.string(),
-  projectId: z13.string(),
+var scheduleDtoSchema = z14.object({
+  id: z14.string(),
+  projectId: z14.string(),
   /** Run kind dispatched when this schedule fires. Defaults to 'answer-visibility' for legacy rows. */
   kind: schedulableRunKindSchema,
-  cronExpr: z13.string(),
-  preset: z13.string().nullable().optional(),
-  timezone: z13.string().default("UTC"),
-  enabled: z13.boolean().default(true),
-  providers: z13.array(providerNameSchema).default([]),
+  cronExpr: z14.string(),
+  preset: z14.string().nullable().optional(),
+  timezone: z14.string().default("UTC"),
+  enabled: z14.boolean().default(true),
+  providers: z14.array(providerNameSchema).default([]),
   /** Traffic-source UUID for `kind === 'traffic-sync'` schedules. Null otherwise. */
-  sourceId: z13.string().nullable().optional(),
-  lastRunAt: z13.string().nullable().optional(),
-  nextRunAt: z13.string().nullable().optional(),
-  createdAt: z13.string(),
-  updatedAt: z13.string()
+  sourceId: z14.string().nullable().optional(),
+  lastRunAt: z14.string().nullable().optional(),
+  nextRunAt: z14.string().nullable().optional(),
+  createdAt: z14.string(),
+  updatedAt: z14.string()
 });
-var scheduleUpsertRequestSchema = z13.object({
+var scheduleUpsertRequestSchema = z14.object({
   /** Run kind. Defaults to 'answer-visibility' so existing callers don't have to change. */
   kind: schedulableRunKindSchema.optional(),
-  preset: z13.string().optional(),
-  cron: z13.string().optional(),
-  timezone: z13.string().optional().default("UTC"),
-  enabled: z13.boolean().optional().default(true),
-  providers: z13.array(providerNameSchema).optional().default([]),
+  preset: z14.string().optional(),
+  cron: z14.string().optional(),
+  timezone: z14.string().optional().default("UTC"),
+  enabled: z14.boolean().optional().default(true),
+  providers: z14.array(providerNameSchema).optional().default([]),
   /** Required when kind === 'traffic-sync'. Forbidden for other kinds. Validated server-side. */
-  sourceId: z13.string().optional()
+  sourceId: z14.string().optional()
 }).refine(
   (data) => data.preset && !data.cron || !data.preset && data.cron,
   { message: 'Exactly one of "preset" or "cron" must be provided' }
 );
 
 // ../contracts/src/analytics.ts
-import { z as z14 } from "zod";
-var metricsWindowSchema = z14.enum(["7d", "30d", "90d", "all"]);
-var trendDirectionSchema = z14.enum(["improving", "declining", "stable"]);
-var visibilityMetricModeSchema = z14.enum(["mentioned", "cited"]);
+import { z as z15 } from "zod";
+var metricsWindowSchema = z15.enum(["7d", "30d", "90d", "all"]);
+var trendDirectionSchema = z15.enum(["improving", "declining", "stable"]);
+var visibilityMetricModeSchema = z15.enum(["mentioned", "cited"]);
 var VisibilityMetricModes = visibilityMetricModeSchema.enum;
-var providerMetricSchema = z14.object({
-  citationRate: z14.number(),
-  cited: z14.number().int(),
-  total: z14.number().int(),
-  mentionRate: z14.number(),
-  mentionedCount: z14.number().int()
-});
-var timeBucketSchema = z14.object({
-  startDate: z14.string(),
-  endDate: z14.string(),
-  citationRate: z14.number(),
-  cited: z14.number().int(),
-  total: z14.number().int(),
-  queryCount: z14.number().int(),
-  mentionRate: z14.number(),
-  mentionedCount: z14.number().int(),
-  byProvider: z14.record(z14.string(), providerMetricSchema)
-});
-var queryChangeEventSchema = z14.object({
-  date: z14.string(),
-  delta: z14.number().int(),
-  label: z14.string()
-});
-var brandMetricsDtoSchema = z14.object({
+var providerMetricSchema = z15.object({
+  citationRate: z15.number(),
+  cited: z15.number().int(),
+  total: z15.number().int(),
+  mentionRate: z15.number(),
+  mentionedCount: z15.number().int()
+});
+var timeBucketSchema = z15.object({
+  startDate: z15.string(),
+  endDate: z15.string(),
+  citationRate: z15.number(),
+  cited: z15.number().int(),
+  total: z15.number().int(),
+  queryCount: z15.number().int(),
+  mentionRate: z15.number(),
+  mentionedCount: z15.number().int(),
+  byProvider: z15.record(z15.string(), providerMetricSchema)
+});
+var queryChangeEventSchema = z15.object({
+  date: z15.string(),
+  delta: z15.number().int(),
+  label: z15.string()
+});
+var brandMetricsDtoSchema = z15.object({
   window: metricsWindowSchema,
-  buckets: z14.array(timeBucketSchema),
+  buckets: z15.array(timeBucketSchema),
   overall: providerMetricSchema,
-  byProvider: z14.record(z14.string(), providerMetricSchema),
+  byProvider: z15.record(z15.string(), providerMetricSchema),
   trend: trendDirectionSchema,
   mentionTrend: trendDirectionSchema,
-  queryChanges: z14.array(queryChangeEventSchema)
+  queryChanges: z15.array(queryChangeEventSchema)
 });
 function parseWindow(value) {
   if (value === "7d" || value === "30d" || value === "90d" || value === "all") return value;
@@ -1707,29 +1735,29 @@ function categoryLabel(category) {
 }
 
 // ../contracts/src/ga.ts
-import { z as z15 } from "zod";
-var ga4ConnectionDtoSchema = z15.object({
-  id: z15.string(),
-  projectId: z15.string(),
-  propertyId: z15.string(),
-  clientEmail: z15.string(),
-  connected: z15.boolean(),
-  createdAt: z15.string(),
-  updatedAt: z15.string()
-});
-var ga4TrafficSnapshotDtoSchema = z15.object({
-  date: z15.string(),
-  landingPage: z15.string(),
-  sessions: z15.number(),
-  organicSessions: z15.number(),
-  users: z15.number()
-});
-var ga4SourceDimensionSchema = z15.enum(["session", "first_user", "manual_utm"]);
-var ga4AiReferralDtoSchema = z15.object({
-  source: z15.string(),
-  medium: z15.string(),
-  sessions: z15.number(),
-  users: z15.number(),
+import { z as z16 } from "zod";
+var ga4ConnectionDtoSchema = z16.object({
+  id: z16.string(),
+  projectId: z16.string(),
+  propertyId: z16.string(),
+  clientEmail: z16.string(),
+  connected: z16.boolean(),
+  createdAt: z16.string(),
+  updatedAt: z16.string()
+});
+var ga4TrafficSnapshotDtoSchema = z16.object({
+  date: z16.string(),
+  landingPage: z16.string(),
+  sessions: z16.number(),
+  organicSessions: z16.number(),
+  users: z16.number()
+});
+var ga4SourceDimensionSchema = z16.enum(["session", "first_user", "manual_utm"]);
+var ga4AiReferralDtoSchema = z16.object({
+  source: z16.string(),
+  medium: z16.string(),
+  sessions: z16.number(),
+  users: z16.number(),
   /**
    * The winning attribution dimension for this (source, medium) tuple — the
    * one with the highest session count. GA4 emits one row per dimension
@@ -1739,144 +1767,144 @@ var ga4AiReferralDtoSchema = z15.object({
    */
   sourceDimension: ga4SourceDimensionSchema
 });
-var ga4AiReferralLandingPageDtoSchema = z15.object({
-  source: z15.string(),
-  medium: z15.string(),
+var ga4AiReferralLandingPageDtoSchema = z16.object({
+  source: z16.string(),
+  medium: z16.string(),
   /**
    * The winning attribution dimension for this (source, medium, landingPage)
    * tuple — the one with the highest session count.
    */
   sourceDimension: ga4SourceDimensionSchema,
-  landingPage: z15.string(),
-  sessions: z15.number(),
-  users: z15.number()
-});
-var ga4SocialReferralDtoSchema = z15.object({
-  source: z15.string(),
-  medium: z15.string(),
-  sessions: z15.number(),
-  users: z15.number(),
+  landingPage: z16.string(),
+  sessions: z16.number(),
+  users: z16.number()
+});
+var ga4SocialReferralDtoSchema = z16.object({
+  source: z16.string(),
+  medium: z16.string(),
+  sessions: z16.number(),
+  users: z16.number(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z15.string()
+  channelGroup: z16.string()
 });
-var ga4ChannelBucketDtoSchema = z15.object({
-  sessions: z15.number(),
-  sharePct: z15.number(),
-  sharePctDisplay: z15.string()
+var ga4ChannelBucketDtoSchema = z16.object({
+  sessions: z16.number(),
+  sharePct: z16.number(),
+  sharePctDisplay: z16.string()
 });
-var ga4ChannelBreakdownDtoSchema = z15.object({
+var ga4ChannelBreakdownDtoSchema = z16.object({
   organic: ga4ChannelBucketDtoSchema,
   social: ga4ChannelBucketDtoSchema,
   direct: ga4ChannelBucketDtoSchema,
   ai: ga4ChannelBucketDtoSchema,
   other: ga4ChannelBucketDtoSchema
 });
-var ga4TrafficSummaryDtoSchema = z15.object({
-  totalSessions: z15.number(),
-  totalOrganicSessions: z15.number(),
+var ga4TrafficSummaryDtoSchema = z16.object({
+  totalSessions: z16.number(),
+  totalOrganicSessions: z16.number(),
   /** Direct-channel sessions (sessions with no source — bookmarks, typed URLs, AI-driven traffic with stripped referrer). 0 for legacy rows from before the column was added. */
-  totalDirectSessions: z15.number(),
-  totalUsers: z15.number(),
-  topPages: z15.array(z15.object({
-    landingPage: z15.string(),
-    sessions: z15.number(),
-    organicSessions: z15.number(),
+  totalDirectSessions: z16.number(),
+  totalUsers: z16.number(),
+  topPages: z16.array(z16.object({
+    landingPage: z16.string(),
+    sessions: z16.number(),
+    organicSessions: z16.number(),
     /** Per-page Direct-channel sessions. 0 for legacy rows. */
-    directSessions: z15.number(),
-    users: z15.number()
+    directSessions: z16.number(),
+    users: z16.number()
   })),
-  aiReferrals: z15.array(ga4AiReferralDtoSchema),
-  aiReferralLandingPages: z15.array(ga4AiReferralLandingPageDtoSchema),
+  aiReferrals: z16.array(ga4AiReferralDtoSchema),
+  aiReferralLandingPages: z16.array(ga4AiReferralLandingPageDtoSchema),
   /** Deduped AI session total: MAX(sessions) per date+source+medium across attribution dimensions, then summed. Cross-cutting: can overlap with Direct/Organic/Social via firstUserSource. */
-  aiSessionsDeduped: z15.number(),
+  aiSessionsDeduped: z16.number(),
   /** Deduped AI user total: MAX(users) per date+source+medium across attribution dimensions, then summed. */
-  aiUsersDeduped: z15.number(),
+  aiUsersDeduped: z16.number(),
   /** AI sessions whose CURRENT sessionSource matched an AI engine. Can overlap with raw Organic/Social/Direct totals; `channelBreakdown` removes those overlaps for display. */
-  aiSessionsBySession: z15.number(),
+  aiSessionsBySession: z16.number(),
   /** AI users whose CURRENT sessionSource matched an AI engine. Can overlap with raw Organic/Social/Direct totals. */
-  aiUsersBySession: z15.number(),
-  socialReferrals: z15.array(ga4SocialReferralDtoSchema),
+  aiUsersBySession: z16.number(),
+  socialReferrals: z16.array(ga4SocialReferralDtoSchema),
   /** Total social sessions (session-scoped, no cross-dimension dedup needed). */
-  socialSessions: z15.number(),
+  socialSessions: z16.number(),
   /** Total social users (session-scoped, no cross-dimension dedup needed). */
-  socialUsers: z15.number(),
+  socialUsers: z16.number(),
   /** Five disjoint buckets used for the channel breakdown. Known AI session-source matches are removed from their native GA4 bucket before shares are computed. */
   channelBreakdown: ga4ChannelBreakdownDtoSchema,
   /** Organic sessions as a percentage of total sessions (0–100, rounded). */
-  organicSharePct: z15.number(),
+  organicSharePct: z16.number(),
   /** Deduped AI sessions as a percentage of total sessions (0–100, rounded). Cross-cutting: can overlap with Direct/Organic/Social. */
-  aiSharePct: z15.number(),
+  aiSharePct: z16.number(),
   /** Session-source-only AI sessions as a percentage of total sessions (0–100, rounded). Can overlap with raw Organic/Social/Direct totals. */
-  aiSharePctBySession: z15.number(),
+  aiSharePctBySession: z16.number(),
   /** Direct-channel sessions as a percentage of total sessions (0–100, rounded). */
-  directSharePct: z15.number(),
+  directSharePct: z16.number(),
   /** Social sessions as a percentage of total sessions (0–100, rounded). */
-  socialSharePct: z15.number(),
+  socialSharePct: z16.number(),
   /** Display string for organicSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  organicSharePctDisplay: z15.string(),
+  organicSharePctDisplay: z16.string(),
   /** Display string for aiSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  aiSharePctDisplay: z15.string(),
+  aiSharePctDisplay: z16.string(),
   /** Display string for aiSharePctBySession: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  aiSharePctBySessionDisplay: z15.string(),
+  aiSharePctBySessionDisplay: z16.string(),
   /** Display string for directSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  directSharePctDisplay: z15.string(),
+  directSharePctDisplay: z16.string(),
   /** Display string for socialSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  socialSharePctDisplay: z15.string(),
+  socialSharePctDisplay: z16.string(),
   /** Sessions not covered by Organic, Social, Direct, or AI (session) channels — e.g. Referral, Email, Paid Search, Display. Always non-negative; clamped to 0 when the four disjoint channels sum above total (rounding edge). */
-  otherSessions: z15.number(),
+  otherSessions: z16.number(),
   /** Other sessions as a percentage of total sessions (0–100, rounded). */
-  otherSharePct: z15.number(),
+  otherSharePct: z16.number(),
   /** Display string for otherSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
-  otherSharePctDisplay: z15.string(),
-  lastSyncedAt: z15.string().nullable()
-});
-var ga4StatusDtoSchema = z15.object({
-  connected: z15.boolean(),
-  propertyId: z15.string().nullable(),
-  clientEmail: z15.string().nullable(),
-  authMethod: z15.enum(["service-account", "oauth"]).nullable(),
-  lastSyncedAt: z15.string().nullable(),
-  createdAt: z15.string().nullable().optional(),
-  updatedAt: z15.string().nullable().optional()
-});
-var ga4SyncResponseDtoSchema = z15.object({
-  synced: z15.boolean(),
-  rowCount: z15.number().int().nonnegative(),
-  aiReferralCount: z15.number().int().nonnegative(),
-  socialReferralCount: z15.number().int().nonnegative(),
-  days: z15.number().int().nonnegative(),
-  syncedAt: z15.string(),
+  otherSharePctDisplay: z16.string(),
+  lastSyncedAt: z16.string().nullable()
+});
+var ga4StatusDtoSchema = z16.object({
+  connected: z16.boolean(),
+  propertyId: z16.string().nullable(),
+  clientEmail: z16.string().nullable(),
+  authMethod: z16.enum(["service-account", "oauth"]).nullable(),
+  lastSyncedAt: z16.string().nullable(),
+  createdAt: z16.string().nullable().optional(),
+  updatedAt: z16.string().nullable().optional()
+});
+var ga4SyncResponseDtoSchema = z16.object({
+  synced: z16.boolean(),
+  rowCount: z16.number().int().nonnegative(),
+  aiReferralCount: z16.number().int().nonnegative(),
+  socialReferralCount: z16.number().int().nonnegative(),
+  days: z16.number().int().nonnegative(),
+  syncedAt: z16.string(),
   /**
    * Components that were written this run. Present when `only` is set.
    * Always includes `traffic` and `summary` (the share denominator) plus
    * the requested channel breakdown — `ai` and/or `social`.
    */
-  syncedComponents: z15.array(z15.string()).optional()
-});
-var ga4AiReferralHistoryEntrySchema = z15.object({
-  date: z15.string(),
-  source: z15.string(),
-  medium: z15.string(),
-  landingPage: z15.string(),
-  sessions: z15.number(),
-  users: z15.number(),
+  syncedComponents: z16.array(z16.string()).optional()
+});
+var ga4AiReferralHistoryEntrySchema = z16.object({
+  date: z16.string(),
+  source: z16.string(),
+  medium: z16.string(),
+  landingPage: z16.string(),
+  sessions: z16.number(),
+  users: z16.number(),
   /** Which GA4 dimension this row came from: session (sessionSource), first_user (firstUserSource), or manual_utm (utm_source parameter) */
   sourceDimension: ga4SourceDimensionSchema
 });
-var ga4SocialReferralHistoryEntrySchema = z15.object({
-  date: z15.string(),
-  source: z15.string(),
-  medium: z15.string(),
-  sessions: z15.number(),
-  users: z15.number(),
+var ga4SocialReferralHistoryEntrySchema = z16.object({
+  date: z16.string(),
+  source: z16.string(),
+  medium: z16.string(),
+  sessions: z16.number(),
+  users: z16.number(),
   /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z15.string()
+  channelGroup: z16.string()
 });
-var ga4SessionHistoryEntrySchema = z15.object({
-  date: z15.string(),
-  sessions: z15.number(),
-  organicSessions: z15.number(),
-  users: z15.number()
+var ga4SessionHistoryEntrySchema = z16.object({
+  date: z16.string(),
+  sessions: z16.number(),
+  organicSessions: z16.number(),
+  users: z16.number()
 });
 
 // ../contracts/src/answer-visibility.ts
@@ -2044,149 +2072,149 @@ function escapeRegExp(value) {
 }
 
 // ../contracts/src/agent.ts
-import { z as z16 } from "zod";
-var agentProviderIdSchema = z16.enum(["claude", "openai", "gemini", "zai"]);
-var agentProviderOptionDtoSchema = z16.object({
+import { z as z17 } from "zod";
+var agentProviderIdSchema = z17.enum(["claude", "openai", "gemini", "zai"]);
+var agentProviderOptionDtoSchema = z17.object({
   /** Stable identifier — what clients pass back as `provider` on the prompt endpoint. */
   id: agentProviderIdSchema,
   /** Human-readable label for UI pickers, e.g. "Anthropic (Claude)". */
-  label: z16.string(),
+  label: z17.string(),
   /** Default model if the caller doesn't pick one. */
-  defaultModel: z16.string(),
+  defaultModel: z17.string(),
   /** Whether a usable API key was found (config.yaml or provider env var). */
-  configured: z16.boolean(),
+  configured: z17.boolean(),
   /**
    * Where the key resolved from, if any. `null` when `configured === false`.
    * Surfaced so the UI can nudge users toward their preferred source of truth.
    */
-  keySource: z16.enum(["config", "env"]).nullable()
+  keySource: z17.enum(["config", "env"]).nullable()
 });
-var agentProvidersResponseDtoSchema = z16.object({
+var agentProvidersResponseDtoSchema = z17.object({
   /**
    * Every provider Aero knows about. `configured === false` entries are
    * included so the UI can render them disabled with an onboarding hint.
    */
-  providers: z16.array(agentProviderOptionDtoSchema).default([]),
+  providers: z17.array(agentProviderOptionDtoSchema).default([]),
   /**
    * Provider Aero auto-picks when no explicit override is passed. Null if
    * nothing is configured (install never exchanged a key).
    */
   defaultProvider: agentProviderIdSchema.nullable()
 });
-var memorySourceSchema = z16.enum(["aero", "user", "compaction"]);
+var memorySourceSchema = z17.enum(["aero", "user", "compaction"]);
 var MemorySources = memorySourceSchema.enum;
 var AGENT_MEMORY_VALUE_MAX_BYTES = 2 * 1024;
 var AGENT_MEMORY_KEY_MAX_LENGTH = 128;
-var agentMemoryUpsertRequestSchema = z16.object({
-  key: z16.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
-  value: z16.string().min(1)
+var agentMemoryUpsertRequestSchema = z17.object({
+  key: z17.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
+  value: z17.string().min(1)
 });
-var agentMemoryDeleteRequestSchema = z16.object({
-  key: z16.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
+var agentMemoryDeleteRequestSchema = z17.object({
+  key: z17.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
 });
 
 // ../contracts/src/backlinks.ts
-import { z as z17 } from "zod";
-var ccReleaseSyncStatusSchema = z17.enum(["queued", "downloading", "querying", "ready", "failed"]);
+import { z as z18 } from "zod";
+var ccReleaseSyncStatusSchema = z18.enum(["queued", "downloading", "querying", "ready", "failed"]);
 var CcReleaseSyncStatuses = ccReleaseSyncStatusSchema.enum;
-var ccReleaseSyncDtoSchema = z17.object({
-  id: z17.string(),
-  release: z17.string(),
+var ccReleaseSyncDtoSchema = z18.object({
+  id: z18.string(),
+  release: z18.string(),
   status: ccReleaseSyncStatusSchema,
-  phaseDetail: z17.string().nullable().optional(),
-  vertexPath: z17.string().nullable().optional(),
-  edgesPath: z17.string().nullable().optional(),
-  vertexSha256: z17.string().nullable().optional(),
-  edgesSha256: z17.string().nullable().optional(),
-  vertexBytes: z17.number().int().nullable().optional(),
-  edgesBytes: z17.number().int().nullable().optional(),
-  projectsProcessed: z17.number().int().nullable().optional(),
-  domainsDiscovered: z17.number().int().nullable().optional(),
-  downloadStartedAt: z17.string().nullable().optional(),
-  downloadFinishedAt: z17.string().nullable().optional(),
-  queryStartedAt: z17.string().nullable().optional(),
-  queryFinishedAt: z17.string().nullable().optional(),
-  error: z17.string().nullable().optional(),
-  createdAt: z17.string(),
-  updatedAt: z17.string()
-});
-var backlinkDomainDtoSchema = z17.object({
-  linkingDomain: z17.string(),
-  numHosts: z17.number().int()
-});
-var backlinkSummaryDtoSchema = z17.object({
-  projectId: z17.string(),
-  release: z17.string(),
-  targetDomain: z17.string(),
-  totalLinkingDomains: z17.number().int(),
-  totalHosts: z17.number().int(),
-  top10HostsShare: z17.string(),
-  queriedAt: z17.string(),
+  phaseDetail: z18.string().nullable().optional(),
+  vertexPath: z18.string().nullable().optional(),
+  edgesPath: z18.string().nullable().optional(),
+  vertexSha256: z18.string().nullable().optional(),
+  edgesSha256: z18.string().nullable().optional(),
+  vertexBytes: z18.number().int().nullable().optional(),
+  edgesBytes: z18.number().int().nullable().optional(),
+  projectsProcessed: z18.number().int().nullable().optional(),
+  domainsDiscovered: z18.number().int().nullable().optional(),
+  downloadStartedAt: z18.string().nullable().optional(),
+  downloadFinishedAt: z18.string().nullable().optional(),
+  queryStartedAt: z18.string().nullable().optional(),
+  queryFinishedAt: z18.string().nullable().optional(),
+  error: z18.string().nullable().optional(),
+  createdAt: z18.string(),
+  updatedAt: z18.string()
+});
+var backlinkDomainDtoSchema = z18.object({
+  linkingDomain: z18.string(),
+  numHosts: z18.number().int()
+});
+var backlinkSummaryDtoSchema = z18.object({
+  projectId: z18.string(),
+  release: z18.string(),
+  targetDomain: z18.string(),
+  totalLinkingDomains: z18.number().int(),
+  totalHosts: z18.number().int(),
+  top10HostsShare: z18.string(),
+  queriedAt: z18.string(),
   // Populated when the response is filtered (e.g. ?excludeCrawlers=1).
   // Counts the rows omitted from totalLinkingDomains/totalHosts so callers
   // can show "N hidden" hints without re-deriving them.
-  excludedLinkingDomains: z17.number().int().optional(),
-  excludedHosts: z17.number().int().optional()
+  excludedLinkingDomains: z18.number().int().optional(),
+  excludedHosts: z18.number().int().optional()
 });
-var backlinkListResponseSchema = z17.object({
+var backlinkListResponseSchema = z18.object({
   summary: backlinkSummaryDtoSchema.nullable(),
-  total: z17.number().int(),
-  rows: z17.array(backlinkDomainDtoSchema)
-});
-var backlinkHistoryEntrySchema = z17.object({
-  release: z17.string(),
-  totalLinkingDomains: z17.number().int(),
-  totalHosts: z17.number().int(),
-  top10HostsShare: z17.string(),
-  queriedAt: z17.string()
-});
-var backlinksInstallStatusDtoSchema = z17.object({
-  duckdbInstalled: z17.boolean(),
-  duckdbVersion: z17.string().nullable().optional(),
-  duckdbSpec: z17.string(),
-  pluginDir: z17.string()
-});
-var backlinksInstallResultDtoSchema = z17.object({
-  installed: z17.boolean(),
-  version: z17.string(),
-  path: z17.string(),
-  alreadyPresent: z17.boolean()
-});
-var ccAvailableReleaseSchema = z17.object({
-  release: z17.string(),
-  vertexUrl: z17.string(),
-  edgesUrl: z17.string(),
-  vertexBytes: z17.number().int().nullable(),
-  edgesBytes: z17.number().int().nullable(),
-  lastModified: z17.string().nullable()
-});
-var ccCachedReleaseSchema = z17.object({
-  release: z17.string(),
+  total: z18.number().int(),
+  rows: z18.array(backlinkDomainDtoSchema)
+});
+var backlinkHistoryEntrySchema = z18.object({
+  release: z18.string(),
+  totalLinkingDomains: z18.number().int(),
+  totalHosts: z18.number().int(),
+  top10HostsShare: z18.string(),
+  queriedAt: z18.string()
+});
+var backlinksInstallStatusDtoSchema = z18.object({
+  duckdbInstalled: z18.boolean(),
+  duckdbVersion: z18.string().nullable().optional(),
+  duckdbSpec: z18.string(),
+  pluginDir: z18.string()
+});
+var backlinksInstallResultDtoSchema = z18.object({
+  installed: z18.boolean(),
+  version: z18.string(),
+  path: z18.string(),
+  alreadyPresent: z18.boolean()
+});
+var ccAvailableReleaseSchema = z18.object({
+  release: z18.string(),
+  vertexUrl: z18.string(),
+  edgesUrl: z18.string(),
+  vertexBytes: z18.number().int().nullable(),
+  edgesBytes: z18.number().int().nullable(),
+  lastModified: z18.string().nullable()
+});
+var ccCachedReleaseSchema = z18.object({
+  release: z18.string(),
   syncStatus: ccReleaseSyncStatusSchema.nullable(),
-  bytes: z17.number().int(),
-  lastUsedAt: z17.string().nullable()
+  bytes: z18.number().int(),
+  lastUsedAt: z18.string().nullable()
 });
 
 // ../contracts/src/composites.ts
-import { z as z18 } from "zod";
-var searchHitKindSchema = z18.enum(["snapshot", "insight"]);
-var projectSearchSnapshotHitSchema = z18.object({
-  kind: z18.literal("snapshot"),
-  id: z18.string(),
-  runId: z18.string(),
-  query: z18.string(),
-  provider: z18.string(),
-  model: z18.string().nullable(),
+import { z as z19 } from "zod";
+var searchHitKindSchema = z19.enum(["snapshot", "insight"]);
+var projectSearchSnapshotHitSchema = z19.object({
+  kind: z19.literal("snapshot"),
+  id: z19.string(),
+  runId: z19.string(),
+  query: z19.string(),
+  provider: z19.string(),
+  model: z19.string().nullable(),
   citationState: citationStateSchema,
-  matchedField: z18.enum(["answerText", "citedDomains", "searchQueries", "query"]),
-  snippet: z18.string(),
-  createdAt: z18.string()
-});
-var projectSearchInsightHitSchema = z18.object({
-  kind: z18.literal("insight"),
-  id: z18.string(),
-  runId: z18.string().nullable(),
-  type: z18.enum([
+  matchedField: z19.enum(["answerText", "citedDomains", "searchQueries", "query"]),
+  snippet: z19.string(),
+  createdAt: z19.string()
+});
+var projectSearchInsightHitSchema = z19.object({
+  kind: z19.literal("insight"),
+  id: z19.string(),
+  runId: z19.string().nullable(),
+  type: z19.enum([
     "regression",
     "gain",
     "opportunity",
@@ -2202,29 +2230,29 @@ var projectSearchInsightHitSchema = z18.object({
     "gbp-metric-drop",
     "gbp-keyword-drop"
   ]),
-  severity: z18.enum(["critical", "high", "medium", "low"]),
-  title: z18.string(),
-  query: z18.string(),
-  provider: z18.string(),
-  matchedField: z18.enum(["title", "query", "recommendation", "cause"]),
-  snippet: z18.string(),
-  dismissed: z18.boolean(),
-  createdAt: z18.string()
-});
-var projectSearchHitSchema = z18.discriminatedUnion("kind", [
+  severity: z19.enum(["critical", "high", "medium", "low"]),
+  title: z19.string(),
+  query: z19.string(),
+  provider: z19.string(),
+  matchedField: z19.enum(["title", "query", "recommendation", "cause"]),
+  snippet: z19.string(),
+  dismissed: z19.boolean(),
+  createdAt: z19.string()
+});
+var projectSearchHitSchema = z19.discriminatedUnion("kind", [
   projectSearchSnapshotHitSchema,
   projectSearchInsightHitSchema
 ]);
-var projectSearchResponseSchema = z18.object({
-  query: z18.string(),
-  totalHits: z18.number().int().nonnegative(),
-  truncated: z18.boolean(),
-  hits: z18.array(projectSearchHitSchema)
+var projectSearchResponseSchema = z19.object({
+  query: z19.string(),
+  totalHits: z19.number().int().nonnegative(),
+  truncated: z19.boolean(),
+  hits: z19.array(projectSearchHitSchema)
 });
 
 // ../contracts/src/content.ts
-import { z as z19 } from "zod";
-var contentActionSchema = z19.enum(["create", "expand", "refresh", "add-schema"]);
+import { z as z20 } from "zod";
+var contentActionSchema = z20.enum(["create", "expand", "refresh", "add-schema"]);
 var ContentActions = contentActionSchema.enum;
 function contentActionLabel(action) {
   switch (action) {
@@ -2238,9 +2266,9 @@ function contentActionLabel(action) {
       return "Add schema";
   }
 }
-var demandSourceSchema = z19.enum(["gsc", "competitor-evidence", "both"]);
+var demandSourceSchema = z20.enum(["gsc", "competitor-evidence", "both"]);
 var DemandSources = demandSourceSchema.enum;
-var actionConfidenceSchema = z19.enum(["high", "medium", "low"]);
+var actionConfidenceSchema = z20.enum(["high", "medium", "low"]);
 var ActionConfidences = actionConfidenceSchema.enum;
 function actionConfidenceLabel(confidence) {
   switch (confidence) {
@@ -2252,7 +2280,7 @@ function actionConfidenceLabel(confidence) {
       return "Low";
   }
 }
-var pageTypeSchema = z19.enum([
+var pageTypeSchema = z20.enum([
   "blog-post",
   "comparison",
   "listicle",
@@ -2261,7 +2289,7 @@ var pageTypeSchema = z19.enum([
   "glossary"
 ]);
 var PageTypes = pageTypeSchema.enum;
-var contentActionStateSchema = z19.enum([
+var contentActionStateSchema = z20.enum([
   "proposed",
   "briefed",
   "payload-generated",
@@ -2271,136 +2299,136 @@ var contentActionStateSchema = z19.enum([
   "dismissed"
 ]);
 var ContentActionStates = contentActionStateSchema.enum;
-var ourBestPageSchema = z19.object({
-  url: z19.string(),
-  gscImpressions: z19.number().nonnegative(),
-  gscClicks: z19.number().nonnegative(),
+var ourBestPageSchema = z20.object({
+  url: z20.string(),
+  gscImpressions: z20.number().nonnegative(),
+  gscClicks: z20.number().nonnegative(),
   // Null when the page came from the inventory fallback (no GSC ranking data).
-  gscAvgPosition: z19.number().nonnegative().nullable(),
-  organicSessions: z19.number().nonnegative()
+  gscAvgPosition: z20.number().nonnegative().nullable(),
+  organicSessions: z20.number().nonnegative()
 });
-var winningCompetitorSchema = z19.object({
-  domain: z19.string(),
-  url: z19.string(),
-  title: z19.string(),
-  citationCount: z19.number().int().nonnegative()
+var winningCompetitorSchema = z20.object({
+  domain: z20.string(),
+  url: z20.string(),
+  title: z20.string(),
+  citationCount: z20.number().int().nonnegative()
 });
-var scoreBreakdownSchema = z19.object({
-  demand: z19.number(),
-  competitor: z19.number(),
-  absence: z19.number(),
-  gapSeverity: z19.number()
+var scoreBreakdownSchema = z20.object({
+  demand: z20.number(),
+  competitor: z20.number(),
+  absence: z20.number(),
+  gapSeverity: z20.number()
 });
-var existingActionRefSchema = z19.object({
-  actionId: z19.string(),
+var existingActionRefSchema = z20.object({
+  actionId: z20.string(),
   state: contentActionStateSchema,
-  lastUpdated: z19.string()
+  lastUpdated: z20.string()
 });
-var contentTargetRowDtoSchema = z19.object({
-  targetRef: z19.string(),
-  query: z19.string(),
+var contentTargetRowDtoSchema = z20.object({
+  targetRef: z20.string(),
+  query: z20.string(),
   action: contentActionSchema,
   ourBestPage: ourBestPageSchema.nullable(),
   winningCompetitor: winningCompetitorSchema.nullable(),
-  score: z19.number(),
+  score: z20.number(),
   scoreBreakdown: scoreBreakdownSchema,
-  drivers: z19.array(z19.string()),
+  drivers: z20.array(z20.string()),
   demandSource: demandSourceSchema,
   actionConfidence: actionConfidenceSchema,
   existingAction: existingActionRefSchema.nullable()
 });
-var contentTargetsResponseDtoSchema = z19.object({
-  targets: z19.array(contentTargetRowDtoSchema),
-  contextMetrics: z19.object({
-    totalAiReferralSessions: z19.number().int().nonnegative(),
-    latestRunId: z19.string(),
-    runTimestamp: z19.string()
+var contentTargetsResponseDtoSchema = z20.object({
+  targets: z20.array(contentTargetRowDtoSchema),
+  contextMetrics: z20.object({
+    totalAiReferralSessions: z20.number().int().nonnegative(),
+    latestRunId: z20.string(),
+    runTimestamp: z20.string()
   })
 });
-var contentTargetDismissalDtoSchema = z19.object({
-  targetRef: z19.string(),
-  addressedUrl: z19.string().nullable(),
-  note: z19.string().nullable(),
-  dismissedAt: z19.string()
+var contentTargetDismissalDtoSchema = z20.object({
+  targetRef: z20.string(),
+  addressedUrl: z20.string().nullable(),
+  note: z20.string().nullable(),
+  dismissedAt: z20.string()
 });
-var contentTargetDismissalsResponseDtoSchema = z19.object({
-  dismissals: z19.array(contentTargetDismissalDtoSchema)
+var contentTargetDismissalsResponseDtoSchema = z20.object({
+  dismissals: z20.array(contentTargetDismissalDtoSchema)
 });
-var contentTargetDismissRequestSchema = z19.object({
-  targetRef: z19.string().min(1),
+var contentTargetDismissRequestSchema = z20.object({
+  targetRef: z20.string().min(1),
   /** URL of the page the user wrote that addresses this recommendation. Stored verbatim for the audit trail; not currently used to suppress the slug-token matcher. */
-  addressedUrl: z19.string().url().optional(),
+  addressedUrl: z20.string().url().optional(),
   /** Free-form note (e.g. "covered in our Q1 content sprint"). 500 char cap is the API surface limit; the DB column is unbounded. */
-  note: z19.string().max(500).optional()
+  note: z20.string().max(500).optional()
 });
-var recommendationExplanationDtoSchema = z19.object({
-  targetRef: z19.string(),
+var recommendationExplanationDtoSchema = z20.object({
+  targetRef: z20.string(),
   /** Version of the prompt template used. Bumping the version invalidates the cache forward without touching the table. */
-  promptVersion: z19.string(),
+  promptVersion: z20.string(),
   /** Provider that produced the explanation (e.g. "claude", "gemini"). */
-  provider: z19.string(),
+  provider: z20.string(),
   /** Model id within that provider (e.g. "claude-sonnet-4-6"). */
-  model: z19.string(),
+  model: z20.string(),
   /** Markdown-formatted rationale + recommended next steps. */
-  responseText: z19.string(),
+  responseText: z20.string(),
   /** Estimated cost in millicents (1/100 of a cent). 0 when unknown. */
-  costMillicents: z19.number().int().nonnegative(),
-  generatedAt: z19.string()
+  costMillicents: z20.number().int().nonnegative(),
+  generatedAt: z20.string()
 });
-var recommendationExplainRequestSchema = z19.object({
+var recommendationExplainRequestSchema = z20.object({
   /**
    * Optional provider override (e.g. "claude" to force Claude even if
    * the project's default is Gemini). Falls through to project default
    * → auto-detect when omitted.
    */
-  provider: z19.string().optional(),
+  provider: z20.string().optional(),
   /**
    * Optional model override within the chosen provider. Falls through to
    * the `analyze`-tier default model when omitted.
    */
-  model: z19.string().optional(),
+  model: z20.string().optional(),
   /**
    * Force a fresh LLM call even if a cached explanation exists for the
    * current prompt version. Use sparingly — defeats the cache.
    */
-  forceRefresh: z19.boolean().optional()
-});
-var contentGroundingSourceSchema = z19.object({
-  uri: z19.string(),
-  title: z19.string(),
-  domain: z19.string(),
-  isOurDomain: z19.boolean(),
-  isCompetitor: z19.boolean(),
-  citationCount: z19.number().int().nonnegative(),
-  providers: z19.array(providerNameSchema)
-});
-var contentSourceRowDtoSchema = z19.object({
-  query: z19.string(),
-  groundingSources: z19.array(contentGroundingSourceSchema)
-});
-var contentSourcesResponseDtoSchema = z19.object({
-  sources: z19.array(contentSourceRowDtoSchema),
-  latestRunId: z19.string()
+  forceRefresh: z20.boolean().optional()
 });
-var contentGapRowDtoSchema = z19.object({
-  query: z19.string(),
-  competitorDomains: z19.array(z19.string()),
-  competitorCount: z19.number().int().nonnegative(),
-  missRate: z19.number().min(0).max(1),
-  lastSeenInRunId: z19.string()
-});
-var contentGapsResponseDtoSchema = z19.object({
-  gaps: z19.array(contentGapRowDtoSchema),
-  latestRunId: z19.string()
+var contentGroundingSourceSchema = z20.object({
+  uri: z20.string(),
+  title: z20.string(),
+  domain: z20.string(),
+  isOurDomain: z20.boolean(),
+  isCompetitor: z20.boolean(),
+  citationCount: z20.number().int().nonnegative(),
+  providers: z20.array(providerNameSchema)
+});
+var contentSourceRowDtoSchema = z20.object({
+  query: z20.string(),
+  groundingSources: z20.array(contentGroundingSourceSchema)
+});
+var contentSourcesResponseDtoSchema = z20.object({
+  sources: z20.array(contentSourceRowDtoSchema),
+  latestRunId: z20.string()
+});
+var contentGapRowDtoSchema = z20.object({
+  query: z20.string(),
+  competitorDomains: z20.array(z20.string()),
+  competitorCount: z20.number().int().nonnegative(),
+  missRate: z20.number().min(0).max(1),
+  lastSeenInRunId: z20.string()
+});
+var contentGapsResponseDtoSchema = z20.object({
+  gaps: z20.array(contentGapRowDtoSchema),
+  latestRunId: z20.string()
 });
 
 // ../contracts/src/doctor.ts
-import { z as z20 } from "zod";
-var checkStatusSchema = z20.enum(["ok", "warn", "fail", "skipped"]);
+import { z as z21 } from "zod";
+var checkStatusSchema = z21.enum(["ok", "warn", "fail", "skipped"]);
 var CheckStatuses = checkStatusSchema.enum;
-var checkScopeSchema = z20.enum(["global", "project"]);
+var checkScopeSchema = z21.enum(["global", "project"]);
 var CheckScopes = checkScopeSchema.enum;
-var checkCategorySchema = z20.enum([
+var checkCategorySchema = z21.enum([
   "auth",
   "config",
   "providers",
@@ -2411,31 +2439,31 @@ var checkCategorySchema = z20.enum([
   "agent"
 ]);
 var CheckCategories = checkCategorySchema.enum;
-var checkResultSchema = z20.object({
-  id: z20.string(),
+var checkResultSchema = z21.object({
+  id: z21.string(),
   category: checkCategorySchema,
   scope: checkScopeSchema,
-  title: z20.string(),
+  title: z21.string(),
   status: checkStatusSchema,
-  code: z20.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
-  summary: z20.string(),
-  remediation: z20.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
-  details: z20.record(z20.string(), z20.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
-  durationMs: z20.number().int().nonnegative().describe("How long the check took to execute.")
+  code: z21.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
+  summary: z21.string(),
+  remediation: z21.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
+  details: z21.record(z21.string(), z21.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
+  durationMs: z21.number().int().nonnegative().describe("How long the check took to execute.")
 });
-var doctorReportSchema = z20.object({
+var doctorReportSchema = z21.object({
   scope: checkScopeSchema,
-  project: z20.string().nullable().describe('Project name when scope is "project", null otherwise.'),
-  generatedAt: z20.string().describe("ISO-8601 timestamp when this doctor run started."),
-  durationMs: z20.number().int().nonnegative(),
-  summary: z20.object({
-    total: z20.number().int().nonnegative(),
-    ok: z20.number().int().nonnegative(),
-    warn: z20.number().int().nonnegative(),
-    fail: z20.number().int().nonnegative(),
-    skipped: z20.number().int().nonnegative()
+  project: z21.string().nullable().describe('Project name when scope is "project", null otherwise.'),
+  generatedAt: z21.string().describe("ISO-8601 timestamp when this doctor run started."),
+  durationMs: z21.number().int().nonnegative(),
+  summary: z21.object({
+    total: z21.number().int().nonnegative(),
+    ok: z21.number().int().nonnegative(),
+    warn: z21.number().int().nonnegative(),
+    fail: z21.number().int().nonnegative(),
+    skipped: z21.number().int().nonnegative()
   }),
-  checks: z20.array(checkResultSchema)
+  checks: z21.array(checkResultSchema)
 });
 function summarizeCheckResults(results) {
   const summary = { total: results.length, ok: 0, warn: 0, fail: 0, skipped: 0 };
@@ -2581,52 +2609,52 @@ function normalizeUrlPath(input) {
 }
 
 // ../contracts/src/citations.ts
-import { z as z21 } from "zod";
-var citationCoverageProviderSchema = z21.object({
-  provider: z21.string(),
+import { z as z22 } from "zod";
+var citationCoverageProviderSchema = z22.object({
+  provider: z22.string(),
   citationState: citationStateSchema,
-  cited: z21.boolean(),
-  mentioned: z21.boolean(),
-  runId: z21.string(),
-  runCreatedAt: z21.string()
-});
-var citationCoverageRowSchema = z21.object({
-  queryId: z21.string(),
-  query: z21.string(),
-  providers: z21.array(citationCoverageProviderSchema),
-  citedCount: z21.number().int().nonnegative(),
-  mentionedCount: z21.number().int().nonnegative(),
-  totalProviders: z21.number().int().nonnegative()
-});
-var competitorGapRowSchema = z21.object({
-  queryId: z21.string(),
-  query: z21.string(),
-  provider: z21.string(),
-  citingCompetitors: z21.array(z21.string()),
-  runId: z21.string(),
-  runCreatedAt: z21.string()
-});
-var citationVisibilitySummarySchema = z21.object({
-  providersConfigured: z21.number().int().nonnegative(),
-  providersCiting: z21.number().int().nonnegative(),
-  providersMentioning: z21.number().int().nonnegative(),
-  totalQueries: z21.number().int().nonnegative(),
+  cited: z22.boolean(),
+  mentioned: z22.boolean(),
+  runId: z22.string(),
+  runCreatedAt: z22.string()
+});
+var citationCoverageRowSchema = z22.object({
+  queryId: z22.string(),
+  query: z22.string(),
+  providers: z22.array(citationCoverageProviderSchema),
+  citedCount: z22.number().int().nonnegative(),
+  mentionedCount: z22.number().int().nonnegative(),
+  totalProviders: z22.number().int().nonnegative()
+});
+var competitorGapRowSchema = z22.object({
+  queryId: z22.string(),
+  query: z22.string(),
+  provider: z22.string(),
+  citingCompetitors: z22.array(z22.string()),
+  runId: z22.string(),
+  runCreatedAt: z22.string()
+});
+var citationVisibilitySummarySchema = z22.object({
+  providersConfigured: z22.number().int().nonnegative(),
+  providersCiting: z22.number().int().nonnegative(),
+  providersMentioning: z22.number().int().nonnegative(),
+  totalQueries: z22.number().int().nonnegative(),
   // Cross-tab buckets — each tracked query with at least one snapshot lands
   // in exactly one of these. Queries with zero snapshots are not counted in
   // any bucket; (sum of buckets) ≤ totalQueries.
-  queriesCitedAndMentioned: z21.number().int().nonnegative(),
-  queriesCitedOnly: z21.number().int().nonnegative(),
-  queriesMentionedOnly: z21.number().int().nonnegative(),
-  queriesInvisible: z21.number().int().nonnegative(),
-  latestRunId: z21.string().nullable(),
-  latestRunAt: z21.string().nullable()
-});
-var citationVisibilityResponseSchema = z21.object({
+  queriesCitedAndMentioned: z22.number().int().nonnegative(),
+  queriesCitedOnly: z22.number().int().nonnegative(),
+  queriesMentionedOnly: z22.number().int().nonnegative(),
+  queriesInvisible: z22.number().int().nonnegative(),
+  latestRunId: z22.string().nullable(),
+  latestRunAt: z22.string().nullable()
+});
+var citationVisibilityResponseSchema = z22.object({
   summary: citationVisibilitySummarySchema,
-  byQuery: z21.array(citationCoverageRowSchema),
-  competitorGaps: z21.array(competitorGapRowSchema),
-  status: z21.enum(["ready", "no-data"]),
-  reason: z21.enum(["no-runs-yet", "no-queries"]).optional()
+  byQuery: z22.array(citationCoverageRowSchema),
+  competitorGaps: z22.array(competitorGapRowSchema),
+  status: z22.enum(["ready", "no-data"]),
+  reason: z22.enum(["no-runs-yet", "no-queries"]).optional()
 });
 function emptyCitationVisibility(reason) {
   return {
@@ -2653,46 +2681,46 @@ function citationStateToCited(state) {
 }
 
 // ../contracts/src/report.ts
-import { z as z22 } from "zod";
-var providerLocationTreatmentSchema = z22.enum([
+import { z as z23 } from "zod";
+var providerLocationTreatmentSchema = z23.enum([
   "prompt",
   "request-param",
   "browser-geo",
   "ignored"
 ]);
-var reportMetaLocationSchema = z22.object({
+var reportMetaLocationSchema = z23.object({
   /** Human-readable label as configured on the project (e.g. "michigan"). */
-  label: z22.string(),
+  label: z23.string(),
   /** Resolved city/region/country from the project's `LocationContext`. */
-  city: z22.string(),
-  region: z22.string(),
-  country: z22.string(),
+  city: z23.string(),
+  region: z23.string(),
+  country: z23.string(),
   /**
    * Other locations configured on the project that did NOT power this report.
    * When non-empty, callers should make clear that the report is location-scoped:
    * a separate sweep is needed to see how AI engines respond from each one.
    */
-  otherConfiguredLabels: z22.array(z22.string())
+  otherConfiguredLabels: z23.array(z23.string())
 });
-var reportProviderLocationHandlingSchema = z22.object({
+var reportProviderLocationHandlingSchema = z23.object({
   /** Provider name (matches `query_snapshots.provider`). */
-  provider: z22.string(),
+  provider: z23.string(),
   /** How this provider applied the configured location during this run. */
   treatment: providerLocationTreatmentSchema,
   /** One-sentence explanation suitable for the report. */
-  description: z22.string()
+  description: z23.string()
 });
-var reportMetaSchema = z22.object({
+var reportMetaSchema = z23.object({
   /** ISO timestamp the report was generated (server clock). */
-  generatedAt: z22.string(),
+  generatedAt: z23.string(),
   /** Project the report covers. */
-  project: z22.object({
-    id: z22.string(),
-    name: z22.string(),
-    displayName: z22.string(),
-    canonicalDomain: z22.string(),
-    country: z22.string(),
-    language: z22.string()
+  project: z23.object({
+    id: z23.string(),
+    name: z23.string(),
+    displayName: z23.string(),
+    canonicalDomain: z23.string(),
+    country: z23.string(),
+    language: z23.string()
   }),
   /**
    * The location that powered the latest visibility run, when one was set.
@@ -2707,24 +2735,24 @@ var reportMetaSchema = z22.object({
    * each provider's answer — some providers append it to the prompt, some
    * pass it as a structured request field, and some (CDP) ignore it.
    */
-  providerLocationHandling: z22.array(reportProviderLocationHandlingSchema),
+  providerLocationHandling: z23.array(reportProviderLocationHandlingSchema),
   /** Earliest data point referenced by the report (ISO date). */
-  periodStart: z22.string().nullable(),
+  periodStart: z23.string().nullable(),
   /** Latest data point referenced by the report (ISO date). */
-  periodEnd: z22.string().nullable()
+  periodEnd: z23.string().nullable()
 });
-var reportExecutiveSummarySchema = z22.object({
+var reportExecutiveSummarySchema = z23.object({
   /**
    * 0..100 — share of tracked queries that were cited by at least one
    * provider in the latest run. "Cited" means the project's domain appeared
    * in the source list / grounding the AI used to answer. Computed per-query
    * (not per-(query × provider)) so the rate is invariant to provider count.
    */
-  citationRate: z22.number(),
+  citationRate: z23.number(),
   /** Numerator of `citationRate` — distinct tracked queries cited by ≥1 provider in the latest run. */
-  citedQueryCount: z22.number(),
+  citedQueryCount: z23.number(),
   /** Denominator of `citationRate` — total tracked queries. */
-  totalQueryCount: z22.number(),
+  totalQueryCount: z23.number(),
   /**
    * 0..100 — share of tracked queries where the project's brand or domain
    * appeared in at least one provider's answer text in the latest run.
@@ -2732,68 +2760,68 @@ var reportExecutiveSummarySchema = z22.object({
    * the prose without citing your domain in its sources, and vice versa.
    * Same per-query denominator as `citationRate` for consistency.
    */
-  mentionRate: z22.number(),
+  mentionRate: z23.number(),
   /** Numerator of `mentionRate` — distinct tracked queries mentioned in ≥1 provider's answer text. */
-  mentionedQueryCount: z22.number(),
+  mentionedQueryCount: z23.number(),
   /** Compared to the previous run: 'up' | 'down' | 'flat' | 'unknown' (no prior run). */
-  trend: z22.enum(["up", "down", "flat", "unknown"]),
+  trend: z23.enum(["up", "down", "flat", "unknown"]),
   /** Total tracked queries. */
-  queryCount: z22.number(),
+  queryCount: z23.number(),
   /** Total tracked competitors. */
-  competitorCount: z22.number(),
+  competitorCount: z23.number(),
   /** Number of providers in the latest run. */
-  providerCount: z22.number(),
+  providerCount: z23.number(),
   /** GSC totals across the most-recent sync window. Null when GSC is not connected. */
-  gsc: z22.object({
-    clicks: z22.number(),
-    impressions: z22.number(),
-    ctr: z22.number(),
-    avgPosition: z22.number(),
-    periodStart: z22.string(),
-    periodEnd: z22.string()
+  gsc: z23.object({
+    clicks: z23.number(),
+    impressions: z23.number(),
+    ctr: z23.number(),
+    avgPosition: z23.number(),
+    periodStart: z23.string(),
+    periodEnd: z23.string()
   }).nullable(),
   /** GA4 totals across the most-recent sync period. Null when GA4 is not connected. */
-  ga: z22.object({
-    sessions: z22.number(),
-    users: z22.number(),
-    periodStart: z22.string(),
-    periodEnd: z22.string()
+  ga: z23.object({
+    sessions: z23.number(),
+    users: z23.number(),
+    periodStart: z23.string(),
+    periodEnd: z23.string()
   }).nullable(),
   /** Top 3-5 findings, each rendered as a single-sentence narrative. */
-  findings: z22.array(z22.object({
-    title: z22.string(),
-    detail: z22.string(),
-    tone: z22.enum(["positive", "caution", "negative", "neutral"])
+  findings: z23.array(z23.object({
+    title: z23.string(),
+    detail: z23.string(),
+    tone: z23.enum(["positive", "caution", "negative", "neutral"])
   }))
 });
-var citationCellSchema = z22.object({
-  citationState: z22.enum(["cited", "not-cited", "pending"]),
-  answerMentioned: z22.boolean().nullable(),
-  model: z22.string().nullable()
+var citationCellSchema = z23.object({
+  citationState: z23.enum(["cited", "not-cited", "pending"]),
+  answerMentioned: z23.boolean().nullable(),
+  model: z23.string().nullable()
 });
-var citationScorecardSchema = z22.object({
-  queries: z22.array(z22.string()),
-  providers: z22.array(z22.string()),
+var citationScorecardSchema = z23.object({
+  queries: z23.array(z23.string()),
+  providers: z23.array(z23.string()),
   /** matrix[queryIndex][providerIndex] — null when no snapshot exists for the pair. */
-  matrix: z22.array(z22.array(citationCellSchema.nullable())),
+  matrix: z23.array(z23.array(citationCellSchema.nullable())),
   /** Per-provider citation rate (0..100). */
-  providerRates: z22.array(z22.object({
-    provider: z22.string(),
-    citedCount: z22.number(),
-    totalCount: z22.number(),
-    citationRate: z22.number()
+  providerRates: z23.array(z23.object({
+    provider: z23.string(),
+    citedCount: z23.number(),
+    totalCount: z23.number(),
+    citationRate: z23.number()
   }))
 });
-var competitorRowSchema = z22.object({
-  domain: z22.string(),
+var competitorRowSchema = z23.object({
+  domain: z23.string(),
   /** Number of (query × provider) pairs that cited this competitor. */
-  citationCount: z22.number(),
+  citationCount: z23.number(),
   /** Out-of count for the same denominator. */
-  totalCount: z22.number(),
+  totalCount: z23.number(),
   /** 'High' | 'Moderate' | 'Low' | 'None' — from buildPortfolioProject pressure logic. */
-  pressureLabel: z22.enum(["High", "Moderate", "Low", "None"]),
+  pressureLabel: z23.enum(["High", "Moderate", "Low", "None"]),
   /** Distinct queries on which this competitor was cited. */
-  citedQueries: z22.array(z22.string()),
+  citedQueries: z23.array(z23.string()),
   /**
    * Citation share 0..100. Numerator = this competitor's `citationCount`.
    * Denominator = sum of `citationCount` across all competitors plus the
@@ -2801,30 +2829,30 @@ var competitorRowSchema = z22.object({
    * slots in the snapshot. Distinct from the project-level Mention Share
    * gauge — that one is brand-in-answer-text, this one is domain-in-source-list.
    */
-  sharePct: z22.number(),
+  sharePct: z23.number(),
   /**
    * URLs from the latest run's grounding sources whose host matches this
    * competitor's domain, with the queries each URL was cited for. Empty
    * when no grounding-source data is available (e.g. no `rawResponse` JSON
    * stored for the snapshots).
    */
-  theirCitedPages: z22.array(z22.object({ url: z22.string(), citedFor: z22.array(z22.string()) }))
+  theirCitedPages: z23.array(z23.object({ url: z23.string(), citedFor: z23.array(z23.string()) }))
 });
-var competitorLandscapeSchema = z22.object({
+var competitorLandscapeSchema = z23.object({
   /** Project's own citation count (for the bar chart comparing project vs competitors). */
-  projectCitationCount: z22.number(),
-  competitors: z22.array(competitorRowSchema)
+  projectCitationCount: z23.number(),
+  competitors: z23.array(competitorRowSchema)
 });
-var mentionRowSchema = z22.object({
-  domain: z22.string(),
+var mentionRowSchema = z23.object({
+  domain: z23.string(),
   /** Number of (query × provider) pairs whose answer text mentioned this competitor's brand or domain. */
-  mentionCount: z22.number(),
+  mentionCount: z23.number(),
   /** Out-of count for the same denominator (snapshots that had answer text). */
-  totalCount: z22.number(),
+  totalCount: z23.number(),
   /** 'High' | 'Moderate' | 'Low' | 'None' — mention frequency tier (mirrors CompetitorRow.pressureLabel). */
-  pressureLabel: z22.enum(["High", "Moderate", "Low", "None"]),
+  pressureLabel: z23.enum(["High", "Moderate", "Low", "None"]),
   /** Distinct queries on which this competitor was mentioned. */
-  mentionedQueries: z22.array(z22.string()),
+  mentionedQueries: z23.array(z23.string()),
   /**
    * Mention share 0..100. Numerator = this competitor's `mentionCount`.
    * Denominator = sum of `mentionCount` across all competitors plus the
@@ -2832,129 +2860,129 @@ var mentionRowSchema = z22.object({
    * mention. Per-competitor split of the same head-to-head measure the
    * project's hero `MentionShareDto` gauge headlines.
    */
-  sharePct: z22.number()
+  sharePct: z23.number()
 });
-var mentionLandscapeSchema = z22.object({
+var mentionLandscapeSchema = z23.object({
   /** Project's own mention count (for the bar chart comparing project vs competitors). */
-  projectMentionCount: z22.number(),
+  projectMentionCount: z23.number(),
   /** Snapshots considered — those with non-empty answerText. Drives the totalCount denominator. */
-  totalAnswerSnapshots: z22.number(),
-  competitors: z22.array(mentionRowSchema)
+  totalAnswerSnapshots: z23.number(),
+  competitors: z23.array(mentionRowSchema)
 });
-var aiSourceCategoryBucketSchema = z22.object({
+var aiSourceCategoryBucketSchema = z23.object({
   /** Category slug from packages/contracts/src/source-categories. */
-  category: z22.string(),
+  category: z23.string(),
   /** Display label. */
-  label: z22.string(),
+  label: z23.string(),
   /** Number of citations falling in this category. */
-  count: z22.number(),
+  count: z23.number(),
   /** 0..100 share of total citations. */
-  sharePct: z22.number()
+  sharePct: z23.number()
 });
-var aiSourceOriginSchema = z22.object({
-  categories: z22.array(aiSourceCategoryBucketSchema),
+var aiSourceOriginSchema = z23.object({
+  categories: z23.array(aiSourceCategoryBucketSchema),
   /** Top 20 source domains by citation count (excluding the project's own domain). */
-  topDomains: z22.array(z22.object({
-    domain: z22.string(),
-    count: z22.number(),
+  topDomains: z23.array(z23.object({
+    domain: z23.string(),
+    count: z23.number(),
     /** True when the domain is one of the project's tracked competitors. */
-    isCompetitor: z22.boolean()
+    isCompetitor: z23.boolean()
   }))
 });
-var gscQueryRowSchema = z22.object({
-  query: z22.string(),
-  clicks: z22.number(),
-  impressions: z22.number(),
-  ctr: z22.number(),
-  avgPosition: z22.number(),
+var gscQueryRowSchema = z23.object({
+  query: z23.string(),
+  clicks: z23.number(),
+  impressions: z23.number(),
+  ctr: z23.number(),
+  avgPosition: z23.number(),
   /** Heuristic categorization: 'brand' | 'lead-gen' | 'industry' | 'other'. */
-  category: z22.enum(["brand", "lead-gen", "industry", "other"])
-});
-var gscSectionSchema = z22.object({
-  periodStart: z22.string(),
-  periodEnd: z22.string(),
-  totalClicks: z22.number(),
-  totalImpressions: z22.number(),
-  ctr: z22.number(),
-  avgPosition: z22.number(),
-  topQueries: z22.array(gscQueryRowSchema),
-  categoryBreakdown: z22.array(z22.object({
-    category: z22.enum(["brand", "lead-gen", "industry", "other"]),
-    clicks: z22.number(),
-    impressions: z22.number(),
-    sharePct: z22.number()
+  category: z23.enum(["brand", "lead-gen", "industry", "other"])
+});
+var gscSectionSchema = z23.object({
+  periodStart: z23.string(),
+  periodEnd: z23.string(),
+  totalClicks: z23.number(),
+  totalImpressions: z23.number(),
+  ctr: z23.number(),
+  avgPosition: z23.number(),
+  topQueries: z23.array(gscQueryRowSchema),
+  categoryBreakdown: z23.array(z23.object({
+    category: z23.enum(["brand", "lead-gen", "industry", "other"]),
+    clicks: z23.number(),
+    impressions: z23.number(),
+    sharePct: z23.number()
   })),
-  trend: z22.array(z22.object({ date: z22.string(), clicks: z22.number(), impressions: z22.number() })),
+  trend: z23.array(z23.object({ date: z23.string(), clicks: z23.number(), impressions: z23.number() })),
   /**
    * Tracked AEO queries that have no GSC impressions in the report window.
    * Surfaces queries that may not represent real search demand.
    */
-  trackedButNoGsc: z22.array(z22.string()),
+  trackedButNoGsc: z23.array(z23.string()),
   /**
    * GSC top queries (sorted by impressions desc) that are not tracked as
    * AEO queries — the candidate set for adding to the AEO project.
    */
-  gscButNotTracked: z22.array(z22.string())
-});
-var gaTrafficSectionSchema = z22.object({
-  totalSessions: z22.number(),
-  totalUsers: z22.number(),
-  totalOrganicSessions: z22.number(),
-  periodStart: z22.string(),
-  periodEnd: z22.string(),
-  topLandingPages: z22.array(z22.object({
-    page: z22.string(),
-    sessions: z22.number(),
-    users: z22.number(),
-    organicSessions: z22.number()
+  gscButNotTracked: z23.array(z23.string())
+});
+var gaTrafficSectionSchema = z23.object({
+  totalSessions: z23.number(),
+  totalUsers: z23.number(),
+  totalOrganicSessions: z23.number(),
+  periodStart: z23.string(),
+  periodEnd: z23.string(),
+  topLandingPages: z23.array(z23.object({
+    page: z23.string(),
+    sessions: z23.number(),
+    users: z23.number(),
+    organicSessions: z23.number()
   })),
-  channelBreakdown: z22.array(z22.object({
-    channel: z22.string(),
-    sessions: z22.number(),
-    sharePct: z22.number()
+  channelBreakdown: z23.array(z23.object({
+    channel: z23.string(),
+    sessions: z23.number(),
+    sharePct: z23.number()
   }))
 });
-var socialReferralSectionSchema = z22.object({
-  totalSessions: z22.number(),
-  organicSessions: z22.number(),
-  paidSessions: z22.number(),
-  channels: z22.array(z22.object({
-    channelGroup: z22.string(),
-    sessions: z22.number(),
-    sharePct: z22.number()
+var socialReferralSectionSchema = z23.object({
+  totalSessions: z23.number(),
+  organicSessions: z23.number(),
+  paidSessions: z23.number(),
+  channels: z23.array(z23.object({
+    channelGroup: z23.string(),
+    sessions: z23.number(),
+    sharePct: z23.number()
   })),
-  topCampaigns: z22.array(z22.object({
-    source: z22.string(),
-    medium: z22.string(),
-    sessions: z22.number()
+  topCampaigns: z23.array(z23.object({
+    source: z23.string(),
+    medium: z23.string(),
+    sessions: z23.number()
   }))
 });
-var aiReferralSectionSchema = z22.object({
-  totalSessions: z22.number(),
-  totalUsers: z22.number(),
-  bySource: z22.array(z22.object({
-    source: z22.string(),
-    sessions: z22.number(),
-    users: z22.number(),
-    sharePct: z22.number()
+var aiReferralSectionSchema = z23.object({
+  totalSessions: z23.number(),
+  totalUsers: z23.number(),
+  bySource: z23.array(z23.object({
+    source: z23.string(),
+    sessions: z23.number(),
+    users: z23.number(),
+    sharePct: z23.number()
   })),
-  trend: z22.array(z22.object({ date: z22.string(), sessions: z22.number() })),
-  topLandingPages: z22.array(z22.object({
-    page: z22.string(),
-    sessions: z22.number(),
-    users: z22.number()
+  trend: z23.array(z23.object({ date: z23.string(), sessions: z23.number() })),
+  topLandingPages: z23.array(z23.object({
+    page: z23.string(),
+    sessions: z23.number(),
+    users: z23.number()
   }))
 });
-var serverActivitySectionSchema = z22.object({
+var serverActivitySectionSchema = z23.object({
   /** ISO8601 inclusive lower bound of the report window (default: 7 days). */
-  windowStart: z22.string(),
+  windowStart: z23.string(),
   /** ISO8601 inclusive upper bound. */
-  windowEnd: z22.string(),
-  hasData: z22.boolean(),
+  windowEnd: z23.string(),
+  hasData: z23.boolean(),
   /** Last-7d total verified crawler hits, with prior 7d for delta. */
-  verifiedCrawlerHits: z22.object({ current: z22.number(), prior: z22.number(), deltaPct: z22.number().nullable() }),
+  verifiedCrawlerHits: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
   /** Last-7d total unverified crawler hits, separated from verified trust metrics. */
-  unverifiedCrawlerHits: z22.object({ current: z22.number(), prior: z22.number(), deltaPct: z22.number().nullable() }),
+  unverifiedCrawlerHits: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
   /**
    * Last-7d on-demand per-user fetches from AI surfaces (ChatGPT-User,
    * Perplexity-User, MistralAI-User). Disjoint from `verifiedCrawlerHits` /
@@ -2963,19 +2991,19 @@ var serverActivitySectionSchema = z22.object({
    * because the operational question for user-fetch is "is this happening?"
    * not "is this a confirmed bot identity?"
    */
-  aiUserFetchHits: z22.object({ current: z22.number(), prior: z22.number(), deltaPct: z22.number().nullable() }),
+  aiUserFetchHits: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
   /** Last-7d AI-referral sessions (sessionized from server-side request evidence). */
-  referralArrivals: z22.object({ current: z22.number(), prior: z22.number(), deltaPct: z22.number().nullable() }),
+  referralArrivals: z23.object({ current: z23.number(), prior: z23.number(), deltaPct: z23.number().nullable() }),
   /** Per-AI-operator breakdown (OpenAI, Anthropic, Google AI, Perplexity, …). */
-  byOperator: z22.array(z22.object({
-    operator: z22.string(),
-    verifiedHits: z22.number(),
+  byOperator: z23.array(z23.object({
+    operator: z23.string(),
+    verifiedHits: z23.number(),
     /** Shown to agency audience only: claimed-bot UA, source IP not in a published range. */
-    unverifiedHits: z22.number(),
+    unverifiedHits: z23.number(),
     /** Per-user fetches from this operator's AI surface (ChatGPT-User, …). */
-    userFetchHits: z22.number(),
-    referralArrivals: z22.number(),
-    deltaPct: z22.number().nullable()
+    userFetchHits: z23.number(),
+    referralArrivals: z23.number(),
+    deltaPct: z23.number().nullable()
   })),
   /**
    * Top crawled paths (verified only, last-7d). Path-level citation cross-reference
@@ -2985,84 +3013,84 @@ var serverActivitySectionSchema = z22.object({
    * citation evidence can extend this entry with a `citationState` field without
    * breaking the contract.
    */
-  topCrawledPaths: z22.array(z22.object({
-    path: z22.string(),
-    verifiedHits: z22.number(),
+  topCrawledPaths: z23.array(z23.object({
+    path: z23.string(),
+    verifiedHits: z23.number(),
     /** How many distinct AI operators crawled this path in the window. */
-    distinctOperators: z22.number()
+    distinctOperators: z23.number()
   })),
   /** AI products that sent ≥1 session in the window (referral by destination). */
-  referralProducts: z22.array(z22.object({
-    product: z22.string(),
-    arrivals: z22.number(),
-    distinctLandingPaths: z22.number()
+  referralProducts: z23.array(z23.object({
+    product: z23.string(),
+    arrivals: z23.number(),
+    distinctLandingPaths: z23.number()
   })),
   /** Daily trend, last 14d for sparkline / chart rendering. */
-  dailyTrend: z22.array(z22.object({
-    date: z22.string(),
-    verifiedCrawlerHits: z22.number(),
-    userFetchHits: z22.number(),
-    referralArrivals: z22.number()
+  dailyTrend: z23.array(z23.object({
+    date: z23.string(),
+    verifiedCrawlerHits: z23.number(),
+    userFetchHits: z23.number(),
+    referralArrivals: z23.number()
   })),
   /**
    * Top landing paths for AI-referral sessions (last-7d).
    * Complements `topCrawledPaths` (what bots fetch) with what humans actually land on.
    */
-  topReferralLandingPaths: z22.array(z22.object({
-    path: z22.string(),
-    arrivals: z22.number(),
-    distinctProducts: z22.number()
+  topReferralLandingPaths: z23.array(z23.object({
+    path: z23.string(),
+    arrivals: z23.number(),
+    distinctProducts: z23.number()
   }))
 });
-var indexingHealthSectionSchema = z22.object({
+var indexingHealthSectionSchema = z23.object({
   /** Source: 'google' | 'bing' | null when neither is connected. */
-  provider: z22.enum(["google", "bing"]).nullable(),
-  total: z22.number(),
-  indexed: z22.number(),
-  notIndexed: z22.number(),
+  provider: z23.enum(["google", "bing"]).nullable(),
+  total: z23.number(),
+  indexed: z23.number(),
+  notIndexed: z23.number(),
   /** Google-only — pages explicitly marked as deindexed. Bing reports 'unknown' instead. */
-  deindexed: z22.number(),
+  deindexed: z23.number(),
   /** Bing-only — pages with no inspection data yet. */
-  unknown: z22.number(),
+  unknown: z23.number(),
   /** 0..100. */
-  indexedPct: z22.number()
+  indexedPct: z23.number()
 });
-var citationsTrendPointSchema = z22.object({
+var citationsTrendPointSchema = z23.object({
   /** Run ID — anchor for cross-section linking. */
-  runId: z22.string(),
+  runId: z23.string(),
   /** ISO timestamp when the run finished (or createdAt fallback). */
-  date: z22.string(),
+  date: z23.string(),
   /**
    * 0..100 — same per-query unique-cited definition as
    * `ReportExecutiveSummary.citationRate`. Stable across runs with different
    * provider counts so the trend line measures real movement rather than
    * provider-count variance.
    */
-  citationRate: z22.number(),
+  citationRate: z23.number(),
   /** Numerator of `citationRate` for this run. */
-  citedQueryCount: z22.number(),
+  citedQueryCount: z23.number(),
   /** Denominator of `citationRate` for this run. */
-  totalQueryCount: z22.number(),
+  totalQueryCount: z23.number(),
   /** 0..100 — same per-query unique-mentioned definition as `ReportExecutiveSummary.mentionRate`. */
-  mentionRate: z22.number(),
+  mentionRate: z23.number(),
   /** Numerator of `mentionRate` for this run. */
-  mentionedQueryCount: z22.number(),
+  mentionedQueryCount: z23.number(),
   /**
    * Per-provider rates for the same run. Each provider's rate is per-pair
    * within that provider (`cited / scanned`), so it remains comparable
    * between providers in the same run.
    */
-  providerRates: z22.array(z22.object({ provider: z22.string(), citationRate: z22.number() }))
-});
-var reportInsightSchema = z22.object({
-  id: z22.string(),
-  type: z22.enum(["regression", "gain", "opportunity"]),
-  severity: z22.enum(["critical", "high", "medium", "low"]),
-  title: z22.string(),
-  query: z22.string(),
-  provider: z22.string(),
-  recommendation: z22.string().nullable(),
-  createdAt: z22.string(),
+  providerRates: z23.array(z23.object({ provider: z23.string(), citationRate: z23.number() }))
+});
+var reportInsightSchema = z23.object({
+  id: z23.string(),
+  type: z23.enum(["regression", "gain", "opportunity"]),
+  severity: z23.enum(["critical", "high", "medium", "low"]),
+  title: z23.string(),
+  query: z23.string(),
+  provider: z23.string(),
+  recommendation: z23.string().nullable(),
+  createdAt: z23.string(),
   /**
    * How many times this insight fired across recent runs for the same
    * `(query, provider, type)` tuple. Always ≥ 1. Insights returned by the
@@ -3070,57 +3098,57 @@ var reportInsightSchema = z22.object({
    * surfacing the multiplicity. Use it directly instead of grouping again
    * client-side — counts derived from raw insight rows will overcount.
    */
-  instanceCount: z22.number()
+  instanceCount: z23.number()
 });
-var recommendedNextStepSchema = z22.object({
+var recommendedNextStepSchema = z23.object({
   /** 'immediate' | 'short-term' | 'medium-term' — bucketed by severity heuristic. */
-  horizon: z22.enum(["immediate", "short-term", "medium-term"]),
-  title: z22.string(),
-  rationale: z22.string()
+  horizon: z23.enum(["immediate", "short-term", "medium-term"]),
+  title: z23.string(),
+  rationale: z23.string()
 });
-var reportRateDeltaSchema = z22.object({
+var reportRateDeltaSchema = z23.object({
   /** Current value (0..100 for rates, raw count otherwise). When `window`
    *  is present this is the average over the last `window` checks. */
-  current: z22.number(),
+  current: z23.number(),
   /** Prior value compared against. When `window` is present this is the
    *  average over the prior `window` checks before that. */
-  prior: z22.number(),
+  prior: z23.number(),
   /** Absolute delta (current − prior). Negative = decrease. */
-  deltaAbs: z22.number(),
+  deltaAbs: z23.number(),
   /**
    * Direction tag for tone mapping. Threshold is metric-specific (3pp for
    * rates, 0.5 for counts) so small noise lands as 'flat' rather than
    * flipping up/down each run.
    */
-  direction: z22.enum(["up", "down", "flat"]),
+  direction: z23.enum(["up", "down", "flat"]),
   /**
    * How many points went into each side of the average. Omitted (or 1)
    * means point-to-point (legacy "since last check"). Higher values mean
    * a rolling-average comparison — renderers should label it as
    * "vs prior N checks" when this is ≥ 2.
    */
-  window: z22.number().optional()
+  window: z23.number().optional()
 });
-var reportProviderMovementSchema = z22.object({
-  provider: z22.string(),
-  current: z22.number(),
-  prior: z22.number(),
-  deltaAbs: z22.number(),
-  direction: z22.enum(["up", "down", "flat"])
+var reportProviderMovementSchema = z23.object({
+  provider: z23.string(),
+  current: z23.number(),
+  prior: z23.number(),
+  deltaAbs: z23.number(),
+  direction: z23.enum(["up", "down", "flat"])
 });
-var whatsChangedSectionSchema = z22.object({
+var whatsChangedSectionSchema = z23.object({
   /**
    * False when there's no prior run (or fewer than the trend baseline),
    * meaning all per-metric deltas will be null. Renderers use this to swap
    * in a "establishing baseline" fallback rather than rendering empty
    * delta tiles.
    */
-  enoughHistory: z22.boolean(),
+  enoughHistory: z23.boolean(),
   /**
    * One-sentence narrative summary suitable as a section subtitle.
    * Always present — even on baseline, narrates whatever signal exists.
    */
-  headline: z22.string(),
+  headline: z23.string(),
   /** Citation rate delta vs the prior completed run. Null when no prior run. */
   citationRate: reportRateDeltaSchema.nullable(),
   /** Mention rate delta vs the prior completed run. Null when no prior run. */
@@ -3143,24 +3171,24 @@ var whatsChangedSectionSchema = z22.object({
    * when no prior run. Sorted by |deltaAbs| desc — providers with the
    * biggest swing first.
    */
-  providerMovements: z22.array(reportProviderMovementSchema),
+  providerMovements: z23.array(reportProviderMovementSchema),
   /**
    * Top wins this period — gains surfaced by the intelligence engine.
    * Capped at 5; sourced from `insights` filtered to `type: 'gain'`.
    */
-  wins: z22.array(reportInsightSchema),
+  wins: z23.array(reportInsightSchema),
   /**
    * Top regressions this period — citations or mentions lost. Capped at 5;
    * sourced from `insights` filtered to `type: 'regression'`.
    */
-  regressions: z22.array(reportInsightSchema)
-});
-var reportAudienceSchema = z22.enum(["agency", "client"]);
-var reportActionAudienceSchema = z22.enum(["agency", "client", "both"]);
-var reportActionHorizonSchema = z22.enum(["immediate", "short-term", "medium-term"]);
-var reportActionConfidenceSchema = z22.enum(["high", "medium", "low"]);
-var reportToneSchema = z22.enum(["positive", "caution", "negative", "neutral"]);
-var reportActionCategorySchema = z22.enum([
+  regressions: z23.array(reportInsightSchema)
+});
+var reportAudienceSchema = z23.enum(["agency", "client"]);
+var reportActionAudienceSchema = z23.enum(["agency", "client", "both"]);
+var reportActionHorizonSchema = z23.enum(["immediate", "short-term", "medium-term"]);
+var reportActionConfidenceSchema = z23.enum(["high", "medium", "low"]);
+var reportToneSchema = z23.enum(["positive", "caution", "negative", "neutral"]);
+var reportActionCategorySchema = z23.enum([
   "content",
   "competitors",
   "provider",
@@ -3169,23 +3197,23 @@ var reportActionCategorySchema = z22.enum([
   "location",
   "monitoring"
 ]);
-var reportActionPlanItemSchema = z22.object({
+var reportActionPlanItemSchema = z23.object({
   /** Which report audience should see this action. `both` renders in both modes. */
   audience: reportActionAudienceSchema,
   /** Stable sort priority. Lower numbers render earlier. */
-  priority: z22.number(),
+  priority: z23.number(),
   /** When this should be tackled. */
   horizon: reportActionHorizonSchema,
   category: reportActionCategorySchema,
-  title: z22.string(),
+  title: z23.string(),
   /** Direct next step written as an operator/client-friendly imperative. */
-  action: z22.string(),
+  action: z23.string(),
   /** Why this matters. Keep each entry concise and evidence-backed. */
-  why: z22.array(z22.string()),
+  why: z23.array(z23.string()),
   /** Specific observations that justify the action. */
-  evidence: z22.array(z22.string()),
+  evidence: z23.array(z23.string()),
   /** What should move if the action worked. */
-  successMetric: z22.string(),
+  successMetric: z23.string(),
   /** Confidence in the recommendation based on the available evidence. */
   confidence: reportActionConfidenceSchema,
   /**
@@ -3197,23 +3225,23 @@ var reportActionPlanItemSchema = z22.object({
    * load. Actions sourced from other signals (competitor gaps, indexing
    * issues, etc.) omit this and use their own dismiss flows.
    */
-  targetRef: z22.string().optional()
+  targetRef: z23.string().optional()
 });
-var reportClientSummarySchema = z22.object({
-  headline: z22.string(),
-  overview: z22.string(),
-  actionItems: z22.array(reportActionPlanItemSchema),
-  confidenceNotes: z22.array(z22.string())
+var reportClientSummarySchema = z23.object({
+  headline: z23.string(),
+  overview: z23.string(),
+  actionItems: z23.array(reportActionPlanItemSchema),
+  confidenceNotes: z23.array(z23.string())
 });
-var reportAgencyDiagnosticSchema = z22.object({
-  title: z22.string(),
-  detail: z22.string(),
-  severity: z22.enum(["positive", "caution", "negative", "neutral"]),
-  evidence: z22.array(z22.string())
+var reportAgencyDiagnosticSchema = z23.object({
+  title: z23.string(),
+  detail: z23.string(),
+  severity: z23.enum(["positive", "caution", "negative", "neutral"]),
+  evidence: z23.array(z23.string())
 });
-var reportAgencyDiagnosticsSchema = z22.object({
-  priorities: z22.array(reportActionPlanItemSchema),
-  diagnostics: z22.array(reportAgencyDiagnosticSchema)
+var reportAgencyDiagnosticsSchema = z23.object({
+  priorities: z23.array(reportActionPlanItemSchema),
+  diagnostics: z23.array(reportAgencyDiagnosticSchema)
 });
 function reportActionTone(action) {
   if (action.horizon === "immediate") return "negative";
@@ -3271,7 +3299,7 @@ function reportConfidenceLabel(confidence) {
       return "Low";
   }
 }
-var projectReportDtoSchema = z22.object({
+var projectReportDtoSchema = z23.object({
   meta: reportMetaSchema,
   executiveSummary: reportExecutiveSummarySchema,
   citationScorecard: citationScorecardSchema,
@@ -3285,16 +3313,16 @@ var projectReportDtoSchema = z22.object({
   /** Server-side log-evidence visibility (crawls + click-through sessions). Null when no traffic source connected. */
   serverActivity: serverActivitySectionSchema.nullable(),
   indexingHealth: indexingHealthSectionSchema.nullable(),
-  citationsTrend: z22.array(citationsTrendPointSchema),
+  citationsTrend: z23.array(citationsTrendPointSchema),
   /**
    * Trend-focused "what's changed" summary for the report's act 2. Always
    * present; renderers gate empty/baseline states via `enoughHistory`.
    */
   whatsChanged: whatsChangedSectionSchema,
-  insights: z22.array(reportInsightSchema),
-  recommendedNextSteps: z22.array(recommendedNextStepSchema),
+  insights: z23.array(reportInsightSchema),
+  recommendedNextSteps: z23.array(recommendedNextStepSchema),
   /** Canonical structured actions shared by the client and agency render modes. */
-  actionPlan: z22.array(reportActionPlanItemSchema),
+  actionPlan: z23.array(reportActionPlanItemSchema),
   /** Polished client-facing summary and action shortlist. */
   clientSummary: reportClientSummarySchema,
   /** Technical, evidence-oriented operator diagnostics for agency mode. */
@@ -3304,17 +3332,17 @@ var projectReportDtoSchema = z22.object({
    * intelligence layer (`buildContentTargetRows`). Empty when no run has
    * produced candidate queries with demand or competitor signal.
    */
-  contentOpportunities: z22.array(contentTargetRowDtoSchema),
+  contentOpportunities: z23.array(contentTargetRowDtoSchema),
   /**
    * Queries where competitors were cited but the project was not. Sourced
    * from `buildContentGapRows`. Empty until the first answer-visibility run.
    */
-  contentGaps: z22.array(contentGapRowDtoSchema),
+  contentGaps: z23.array(contentGapRowDtoSchema),
   /**
    * Per-query grounding source map (own + competitor cited URLs). Sourced
    * from `buildContentSourceRows`. Empty until the first answer-visibility run.
    */
-  groundingSources: z22.array(contentSourceRowDtoSchema)
+  groundingSources: z23.array(contentSourceRowDtoSchema)
 });
 
 // ../contracts/src/report-dedup.ts
@@ -3385,10 +3413,10 @@ function dedupeReportOpportunities(report) {
 }
 
 // ../contracts/src/skills.ts
-import { z as z23 } from "zod";
-var codingAgentSchema = z23.enum(["claude", "codex"]);
+import { z as z24 } from "zod";
+var codingAgentSchema = z24.enum(["claude", "codex"]);
 var CodingAgents = codingAgentSchema.enum;
-var skillsClientSchema = z23.enum(["claude", "codex", "all"]);
+var skillsClientSchema = z24.enum(["claude", "codex", "all"]);
 var SkillsClients = skillsClientSchema.enum;
 var SKILL_MANIFEST_FILENAME = ".canonry-skill-manifest.json";
 function classifySkillFile(params) {
@@ -3406,8 +3434,8 @@ function coerceSkillManifest(parsed) {
 }
 
 // ../contracts/src/traffic.ts
-import { z as z24 } from "zod";
-var trafficSourceTypeSchema = z24.enum([
+import { z as z25 } from "zod";
+var trafficSourceTypeSchema = z25.enum([
   "cloud-run",
   "wordpress",
   "cloudflare",
@@ -3415,7 +3443,7 @@ var trafficSourceTypeSchema = z24.enum([
   "generic-log"
 ]);
 var TrafficSourceTypes = trafficSourceTypeSchema.enum;
-var trafficAdapterCapabilitySchema = z24.enum([
+var trafficAdapterCapabilitySchema = z25.enum([
   "raw-request-events",
   "aggregate-request-metrics",
   "request-url",
@@ -3426,219 +3454,219 @@ var trafficAdapterCapabilitySchema = z24.enum([
   "cursor-pull"
 ]);
 var TrafficAdapterCapabilities = trafficAdapterCapabilitySchema.enum;
-var trafficEvidenceKindSchema = z24.enum(["raw-request", "aggregate-bucket"]);
+var trafficEvidenceKindSchema = z25.enum(["raw-request", "aggregate-bucket"]);
 var TrafficEvidenceKinds = trafficEvidenceKindSchema.enum;
-var trafficEventConfidenceSchema = z24.enum(["observed", "provider-aggregated", "inferred"]);
+var trafficEventConfidenceSchema = z25.enum(["observed", "provider-aggregated", "inferred"]);
 var TrafficEventConfidences = trafficEventConfidenceSchema.enum;
-var trafficProviderResourceSchema = z24.object({
-  type: z24.string().nullable(),
-  labels: z24.record(z24.string(), z24.string())
+var trafficProviderResourceSchema = z25.object({
+  type: z25.string().nullable(),
+  labels: z25.record(z25.string(), z25.string())
 });
-var normalizedTrafficRequestSchema = z24.object({
+var normalizedTrafficRequestSchema = z25.object({
   sourceType: trafficSourceTypeSchema,
-  evidenceKind: z24.literal(TrafficEvidenceKinds["raw-request"]),
-  confidence: z24.literal(TrafficEventConfidences.observed),
-  eventId: z24.string().min(1),
-  observedAt: z24.string().min(1),
-  method: z24.string().nullable(),
-  requestUrl: z24.string().nullable(),
-  host: z24.string().nullable(),
-  path: z24.string().min(1),
-  queryString: z24.string().nullable(),
-  status: z24.number().int().nullable(),
-  userAgent: z24.string().nullable(),
-  remoteIp: z24.string().nullable(),
-  referer: z24.string().nullable(),
-  latencyMs: z24.number().nullable(),
-  requestSizeBytes: z24.number().int().nullable(),
-  responseSizeBytes: z24.number().int().nullable(),
+  evidenceKind: z25.literal(TrafficEvidenceKinds["raw-request"]),
+  confidence: z25.literal(TrafficEventConfidences.observed),
+  eventId: z25.string().min(1),
+  observedAt: z25.string().min(1),
+  method: z25.string().nullable(),
+  requestUrl: z25.string().nullable(),
+  host: z25.string().nullable(),
+  path: z25.string().min(1),
+  queryString: z25.string().nullable(),
+  status: z25.number().int().nullable(),
+  userAgent: z25.string().nullable(),
+  remoteIp: z25.string().nullable(),
+  referer: z25.string().nullable(),
+  latencyMs: z25.number().nullable(),
+  requestSizeBytes: z25.number().int().nullable(),
+  responseSizeBytes: z25.number().int().nullable(),
   providerResource: trafficProviderResourceSchema,
-  providerLabels: z24.record(z24.string(), z24.string())
+  providerLabels: z25.record(z25.string(), z25.string())
 });
-var normalizedTrafficPullPageSchema = z24.object({
-  events: z24.array(normalizedTrafficRequestSchema),
-  rawEntryCount: z24.number().int().nonnegative(),
-  skippedEntryCount: z24.number().int().nonnegative(),
-  nextPageToken: z24.string().optional(),
-  filter: z24.string()
+var normalizedTrafficPullPageSchema = z25.object({
+  events: z25.array(normalizedTrafficRequestSchema),
+  rawEntryCount: z25.number().int().nonnegative(),
+  skippedEntryCount: z25.number().int().nonnegative(),
+  nextPageToken: z25.string().optional(),
+  filter: z25.string()
 });
-var trafficSourceStatusSchema = z24.enum(["connected", "paused", "error", "archived"]);
+var trafficSourceStatusSchema = z25.enum(["connected", "paused", "error", "archived"]);
 var TrafficSourceStatuses = trafficSourceStatusSchema.enum;
-var trafficSourceAuthModeSchema = z24.enum(["oauth", "service-account"]);
+var trafficSourceAuthModeSchema = z25.enum(["oauth", "service-account"]);
 var TrafficSourceAuthModes = trafficSourceAuthModeSchema.enum;
-var verificationStatusSchema = z24.enum(["verified", "claimed_unverified", "unknown_ai_like"]);
+var verificationStatusSchema = z25.enum(["verified", "claimed_unverified", "unknown_ai_like"]);
 var VerificationStatuses = verificationStatusSchema.enum;
-var cloudRunSourceConfigSchema = z24.object({
-  gcpProjectId: z24.string().min(1),
-  serviceName: z24.string().nullable().optional(),
-  location: z24.string().nullable().optional(),
+var cloudRunSourceConfigSchema = z25.object({
+  gcpProjectId: z25.string().min(1),
+  serviceName: z25.string().nullable().optional(),
+  location: z25.string().nullable().optional(),
   authMode: trafficSourceAuthModeSchema
 });
-var wordpressTrafficSourceConfigSchema = z24.object({
-  baseUrl: z24.string().url(),
-  username: z24.string().min(1)
+var wordpressTrafficSourceConfigSchema = z25.object({
+  baseUrl: z25.string().url(),
+  username: z25.string().min(1)
 });
-var vercelTrafficEnvironmentSchema = z24.enum(["production", "preview"]);
+var vercelTrafficEnvironmentSchema = z25.enum(["production", "preview"]);
 var VercelTrafficEnvironments = vercelTrafficEnvironmentSchema.enum;
-var vercelTrafficSourceConfigSchema = z24.object({
+var vercelTrafficSourceConfigSchema = z25.object({
   /** Vercel project id (e.g. `prj_...`). */
-  projectId: z24.string().min(1),
+  projectId: z25.string().min(1),
   /** Vercel team or account id: the org that owns the project. */
-  teamId: z24.string().min(1),
+  teamId: z25.string().min(1),
   environment: vercelTrafficEnvironmentSchema
 });
-var trafficSourceDtoSchema = z24.object({
-  id: z24.string(),
-  projectId: z24.string(),
+var trafficSourceDtoSchema = z25.object({
+  id: z25.string(),
+  projectId: z25.string(),
   sourceType: trafficSourceTypeSchema,
-  displayName: z24.string(),
+  displayName: z25.string(),
   status: trafficSourceStatusSchema,
-  lastSyncedAt: z24.string().nullable(),
-  lastCursor: z24.string().nullable(),
-  lastError: z24.string().nullable(),
-  archivedAt: z24.string().nullable(),
-  config: z24.record(z24.string(), z24.unknown()),
-  createdAt: z24.string(),
-  updatedAt: z24.string()
-});
-var trafficConnectCloudRunRequestSchema = z24.object({
-  gcpProjectId: z24.string().min(1),
-  serviceName: z24.string().min(1).optional(),
-  location: z24.string().min(1).optional(),
-  displayName: z24.string().min(1).optional(),
+  lastSyncedAt: z25.string().nullable(),
+  lastCursor: z25.string().nullable(),
+  lastError: z25.string().nullable(),
+  archivedAt: z25.string().nullable(),
+  config: z25.record(z25.string(), z25.unknown()),
+  createdAt: z25.string(),
+  updatedAt: z25.string()
+});
+var trafficConnectCloudRunRequestSchema = z25.object({
+  gcpProjectId: z25.string().min(1),
+  serviceName: z25.string().min(1).optional(),
+  location: z25.string().min(1).optional(),
+  displayName: z25.string().min(1).optional(),
   /** Service-account JSON content (string). When omitted, defaults to OAuth via `canonry google connect <project> --type ga4` flow. */
-  keyJson: z24.string().optional()
+  keyJson: z25.string().optional()
 });
-var trafficConnectWordpressRequestSchema = z24.object({
-  baseUrl: z24.string().url(),
-  username: z24.string().min(1),
+var trafficConnectWordpressRequestSchema = z25.object({
+  baseUrl: z25.string().url(),
+  username: z25.string().min(1),
   /** WordPress Application Password (the same auth used by the content client). */
-  applicationPassword: z24.string().min(1),
-  displayName: z24.string().min(1).optional()
+  applicationPassword: z25.string().min(1),
+  displayName: z25.string().min(1).optional()
 });
-var trafficConnectVercelRequestSchema = z24.object({
+var trafficConnectVercelRequestSchema = z25.object({
   /** Vercel project id (e.g. `prj_...`) — from the Vercel dashboard or `.vercel/project.json`. */
-  projectId: z24.string().min(1),
+  projectId: z25.string().min(1),
   /** Vercel team or account id: the org that owns the project ("orgId" in .vercel/project.json). */
-  teamId: z24.string().min(1),
+  teamId: z25.string().min(1),
   /** Vercel personal access token. Stored in `~/.canonry/config.yaml`, never the DB. */
-  token: z24.string().min(1),
+  token: z25.string().min(1),
   /** Which deployment environment's request logs to pull. Default: `production`. */
   environment: vercelTrafficEnvironmentSchema.optional(),
-  displayName: z24.string().min(1).optional()
+  displayName: z25.string().min(1).optional()
 });
-var trafficSyncResponseSchema = z24.object({
-  sourceId: z24.string(),
-  runId: z24.string(),
-  syncedAt: z24.string(),
-  pulledEvents: z24.number().int().nonnegative(),
+var trafficSyncResponseSchema = z25.object({
+  sourceId: z25.string(),
+  runId: z25.string(),
+  syncedAt: z25.string(),
+  pulledEvents: z25.number().int().nonnegative(),
   /** Self-traffic events (Canonry's own tooling) dropped before rollup. */
-  selfTrafficExcluded: z24.number().int().nonnegative(),
-  crawlerHits: z24.number().int().nonnegative(),
-  aiUserFetchHits: z24.number().int().nonnegative(),
-  aiReferralHits: z24.number().int().nonnegative(),
-  unknownHits: z24.number().int().nonnegative(),
-  crawlerBucketRows: z24.number().int().nonnegative(),
-  aiUserFetchBucketRows: z24.number().int().nonnegative(),
-  aiReferralBucketRows: z24.number().int().nonnegative(),
-  sampleRows: z24.number().int().nonnegative(),
-  windowStart: z24.string(),
-  windowEnd: z24.string()
-});
-var trafficBackfillRequestSchema = z24.object({
+  selfTrafficExcluded: z25.number().int().nonnegative(),
+  crawlerHits: z25.number().int().nonnegative(),
+  aiUserFetchHits: z25.number().int().nonnegative(),
+  aiReferralHits: z25.number().int().nonnegative(),
+  unknownHits: z25.number().int().nonnegative(),
+  crawlerBucketRows: z25.number().int().nonnegative(),
+  aiUserFetchBucketRows: z25.number().int().nonnegative(),
+  aiReferralBucketRows: z25.number().int().nonnegative(),
+  sampleRows: z25.number().int().nonnegative(),
+  windowStart: z25.string(),
+  windowEnd: z25.string()
+});
+var trafficBackfillRequestSchema = z25.object({
   /** Lookback window in days. Capped server-side at the upstream log retention ceiling (Cloud Logging _Default = 30d). Default: 30. */
-  days: z24.number().int().positive().optional()
+  days: z25.number().int().positive().optional()
 });
-var trafficResetRequestSchema = z24.object({
-  advanceToNow: z24.literal(true)
+var trafficResetRequestSchema = z25.object({
+  advanceToNow: z25.literal(true)
 });
-var trafficBackfillResponseSchema = z24.object({
-  sourceId: z24.string(),
-  runId: z24.string(),
+var trafficBackfillResponseSchema = z25.object({
+  sourceId: z25.string(),
+  runId: z25.string(),
   status: runStatusSchema,
-  windowStart: z24.string(),
-  windowEnd: z24.string(),
+  windowStart: z25.string(),
+  windowEnd: z25.string(),
   /** Days actually used after server-side clamping (≤ requested). */
-  daysRequested: z24.number().int().positive(),
-  daysApplied: z24.number().int().positive()
+  daysRequested: z25.number().int().positive(),
+  daysApplied: z25.number().int().positive()
 });
-var trafficSourceTotalsSchema = z24.object({
-  crawlerHits: z24.number().int().nonnegative(),
-  aiUserFetchHits: z24.number().int().nonnegative(),
-  aiReferralHits: z24.number().int().nonnegative(),
-  sampleCount: z24.number().int().nonnegative()
+var trafficSourceTotalsSchema = z25.object({
+  crawlerHits: z25.number().int().nonnegative(),
+  aiUserFetchHits: z25.number().int().nonnegative(),
+  aiReferralHits: z25.number().int().nonnegative(),
+  sampleCount: z25.number().int().nonnegative()
 });
-var trafficSourceListResponseSchema = z24.object({
-  sources: z24.array(trafficSourceDtoSchema)
+var trafficSourceListResponseSchema = z25.object({
+  sources: z25.array(trafficSourceDtoSchema)
 });
 var trafficSourceDetailDtoSchema = trafficSourceDtoSchema.extend({
   totals24h: trafficSourceTotalsSchema,
-  latestRun: z24.object({
-    runId: z24.string(),
+  latestRun: z25.object({
+    runId: z25.string(),
     status: runStatusSchema,
-    startedAt: z24.string().nullable(),
-    finishedAt: z24.string().nullable(),
-    error: z24.string().nullable()
+    startedAt: z25.string().nullable(),
+    finishedAt: z25.string().nullable(),
+    error: z25.string().nullable()
   }).nullable()
 });
-var trafficStatusResponseSchema = z24.object({
-  sources: z24.array(trafficSourceDetailDtoSchema)
+var trafficStatusResponseSchema = z25.object({
+  sources: z25.array(trafficSourceDetailDtoSchema)
 });
-var trafficEventKindSchema = z24.enum(["crawler", "ai-user-fetch", "ai-referral"]);
+var trafficEventKindSchema = z25.enum(["crawler", "ai-user-fetch", "ai-referral"]);
 var TrafficEventKinds = trafficEventKindSchema.enum;
-var trafficCrawlerEventEntrySchema = z24.object({
-  kind: z24.literal(TrafficEventKinds.crawler),
-  sourceId: z24.string(),
-  tsHour: z24.string(),
-  botId: z24.string(),
-  operator: z24.string(),
-  verificationStatus: z24.string(),
-  pathNormalized: z24.string(),
-  status: z24.number().int(),
-  hits: z24.number().int().nonnegative()
-});
-var trafficAiUserFetchEventEntrySchema = z24.object({
-  kind: z24.literal(TrafficEventKinds["ai-user-fetch"]),
-  sourceId: z24.string(),
-  tsHour: z24.string(),
-  botId: z24.string(),
-  operator: z24.string(),
-  verificationStatus: z24.string(),
-  pathNormalized: z24.string(),
-  status: z24.number().int(),
-  hits: z24.number().int().nonnegative()
-});
-var trafficAiReferralEventEntrySchema = z24.object({
-  kind: z24.literal(TrafficEventKinds["ai-referral"]),
-  sourceId: z24.string(),
-  tsHour: z24.string(),
-  product: z24.string(),
-  operator: z24.string(),
-  sourceDomain: z24.string(),
-  evidenceType: z24.string(),
-  landingPathNormalized: z24.string(),
-  status: z24.number().int(),
-  hits: z24.number().int().nonnegative()
-});
-var trafficEventEntrySchema = z24.discriminatedUnion("kind", [
+var trafficCrawlerEventEntrySchema = z25.object({
+  kind: z25.literal(TrafficEventKinds.crawler),
+  sourceId: z25.string(),
+  tsHour: z25.string(),
+  botId: z25.string(),
+  operator: z25.string(),
+  verificationStatus: z25.string(),
+  pathNormalized: z25.string(),
+  status: z25.number().int(),
+  hits: z25.number().int().nonnegative()
+});
+var trafficAiUserFetchEventEntrySchema = z25.object({
+  kind: z25.literal(TrafficEventKinds["ai-user-fetch"]),
+  sourceId: z25.string(),
+  tsHour: z25.string(),
+  botId: z25.string(),
+  operator: z25.string(),
+  verificationStatus: z25.string(),
+  pathNormalized: z25.string(),
+  status: z25.number().int(),
+  hits: z25.number().int().nonnegative()
+});
+var trafficAiReferralEventEntrySchema = z25.object({
+  kind: z25.literal(TrafficEventKinds["ai-referral"]),
+  sourceId: z25.string(),
+  tsHour: z25.string(),
+  product: z25.string(),
+  operator: z25.string(),
+  sourceDomain: z25.string(),
+  evidenceType: z25.string(),
+  landingPathNormalized: z25.string(),
+  status: z25.number().int(),
+  hits: z25.number().int().nonnegative()
+});
+var trafficEventEntrySchema = z25.discriminatedUnion("kind", [
   trafficCrawlerEventEntrySchema,
   trafficAiUserFetchEventEntrySchema,
   trafficAiReferralEventEntrySchema
 ]);
-var trafficEventsResponseSchema = z24.object({
-  windowStart: z24.string(),
-  windowEnd: z24.string(),
-  totals: z24.object({
-    crawlerHits: z24.number().int().nonnegative(),
-    aiUserFetchHits: z24.number().int().nonnegative(),
-    aiReferralHits: z24.number().int().nonnegative()
+var trafficEventsResponseSchema = z25.object({
+  windowStart: z25.string(),
+  windowEnd: z25.string(),
+  totals: z25.object({
+    crawlerHits: z25.number().int().nonnegative(),
+    aiUserFetchHits: z25.number().int().nonnegative(),
+    aiReferralHits: z25.number().int().nonnegative()
   }),
-  events: z24.array(trafficEventEntrySchema)
+  events: z25.array(trafficEventEntrySchema)
 });
 
 // ../contracts/src/discovery.ts
-import { z as z25 } from "zod";
-var discoveryBucketSchema = z25.enum(["cited", "aspirational", "wasted-surface"]);
+import { z as z26 } from "zod";
+var discoveryBucketSchema = z26.enum(["cited", "aspirational", "wasted-surface"]);
 var DiscoveryBuckets = discoveryBucketSchema.enum;
 var DEFAULT_DISCOVERY_PROMOTE_BUCKETS = [
   DiscoveryBuckets.cited,
@@ -3646,7 +3674,7 @@ var DEFAULT_DISCOVERY_PROMOTE_BUCKETS = [
 ];
 var DISCOVERY_PROMOTE_COMPETITOR_CAP = 20;
 var DISCOVERY_PROMOTE_COMPETITOR_MIN_HITS = 2;
-var discoveryCompetitorTypeSchema = z25.enum([
+var discoveryCompetitorTypeSchema = z26.enum([
   "direct-competitor",
   "ota-aggregator",
   "editorial-media",
@@ -3657,11 +3685,11 @@ var DiscoveryCompetitorTypes = discoveryCompetitorTypeSchema.enum;
 var DEFAULT_DISCOVERY_PROMOTE_COMPETITOR_TYPES = [
   DiscoveryCompetitorTypes["direct-competitor"]
 ];
-var discoverySessionStatusSchema = z25.enum(["queued", "seeding", "probing", "completed", "failed"]);
+var discoverySessionStatusSchema = z26.enum(["queued", "seeding", "probing", "completed", "failed"]);
 var DiscoverySessionStatuses = discoverySessionStatusSchema.enum;
-var discoveryCompetitorMapEntrySchema = z25.object({
-  domain: z25.string().min(1),
-  hits: z25.number().int().positive(),
+var discoveryCompetitorMapEntrySchema = z26.object({
+  domain: z26.string().min(1),
+  hits: z26.number().int().positive(),
   /**
    * Domain classification from the session's post-probe AI classification
    * pass. Defaults to `unknown` so competitor maps persisted before
@@ -3670,43 +3698,43 @@ var discoveryCompetitorMapEntrySchema = z25.object({
    */
   competitorType: discoveryCompetitorTypeSchema.default("unknown")
 });
-var discoveryProbeDtoSchema = z25.object({
-  id: z25.string(),
-  sessionId: z25.string(),
-  projectId: z25.string(),
-  query: z25.string(),
+var discoveryProbeDtoSchema = z26.object({
+  id: z26.string(),
+  sessionId: z26.string(),
+  projectId: z26.string(),
+  query: z26.string(),
   bucket: discoveryBucketSchema.nullable().default(null),
   citationState: citationStateSchema,
-  citedDomains: z25.array(z25.string()).default([]),
-  createdAt: z25.string()
+  citedDomains: z26.array(z26.string()).default([]),
+  createdAt: z26.string()
 });
-var discoverySessionDtoSchema = z25.object({
-  id: z25.string(),
-  projectId: z25.string(),
+var discoverySessionDtoSchema = z26.object({
+  id: z26.string(),
+  projectId: z26.string(),
   status: discoverySessionStatusSchema,
-  icpDescription: z25.string().nullable().optional(),
-  seedProvider: z25.string().nullable().optional(),
-  seedCountRaw: z25.number().int().nullable().optional(),
-  seedCount: z25.number().int().nullable().optional(),
-  dedupThreshold: z25.number().nullable().optional(),
-  probeCount: z25.number().int().nullable().optional(),
-  citedCount: z25.number().int().nullable().default(null),
-  aspirationalCount: z25.number().int().nullable().default(null),
-  wastedCount: z25.number().int().nullable().default(null),
-  competitorMap: z25.array(discoveryCompetitorMapEntrySchema).default([]),
-  error: z25.string().nullable().optional(),
-  startedAt: z25.string().nullable().optional(),
-  finishedAt: z25.string().nullable().optional(),
-  createdAt: z25.string()
+  icpDescription: z26.string().nullable().optional(),
+  seedProvider: z26.string().nullable().optional(),
+  seedCountRaw: z26.number().int().nullable().optional(),
+  seedCount: z26.number().int().nullable().optional(),
+  dedupThreshold: z26.number().nullable().optional(),
+  probeCount: z26.number().int().nullable().optional(),
+  citedCount: z26.number().int().nullable().default(null),
+  aspirationalCount: z26.number().int().nullable().default(null),
+  wastedCount: z26.number().int().nullable().default(null),
+  competitorMap: z26.array(discoveryCompetitorMapEntrySchema).default([]),
+  error: z26.string().nullable().optional(),
+  startedAt: z26.string().nullable().optional(),
+  finishedAt: z26.string().nullable().optional(),
+  createdAt: z26.string()
 });
 var discoverySessionDetailDtoSchema = discoverySessionDtoSchema.extend({
-  probes: z25.array(discoveryProbeDtoSchema).default([])
+  probes: z26.array(discoveryProbeDtoSchema).default([])
 });
 var DISCOVERY_MAX_PROBES_CAP = 500;
-var discoveryRunRequestSchema = z25.object({
-  icpDescription: z25.string().min(1).optional(),
-  dedupThreshold: z25.number().min(0).max(1).optional(),
-  maxProbes: z25.number().int().positive().max(DISCOVERY_MAX_PROBES_CAP).optional(),
+var discoveryRunRequestSchema = z26.object({
+  icpDescription: z26.string().min(1).optional(),
+  dedupThreshold: z26.number().min(0).max(1).optional(),
+  maxProbes: z26.number().int().positive().max(DISCOVERY_MAX_PROBES_CAP).optional(),
   /**
    * Optional override of the project's location labels, constraining seed
    * generation to a subset of the configured service areas. Each label must
@@ -3714,39 +3742,39 @@ var discoveryRunRequestSchema = z25.object({
    * `resolveLocations`). Omitted means "use every project location" — a
    * project with no locations is unaffected.
    */
-  locations: z25.array(z25.string().min(1)).optional()
+  locations: z26.array(z26.string().min(1)).optional()
 });
-var discoveryPromoteRequestSchema = z25.object({
-  buckets: z25.array(discoveryBucketSchema).min(1).optional(),
-  includeCompetitors: z25.boolean().optional(),
-  competitorTypes: z25.array(discoveryCompetitorTypeSchema).min(1).optional()
+var discoveryPromoteRequestSchema = z26.object({
+  buckets: z26.array(discoveryBucketSchema).min(1).optional(),
+  includeCompetitors: z26.boolean().optional(),
+  competitorTypes: z26.array(discoveryCompetitorTypeSchema).min(1).optional()
 });
-var discoveryPromotePreviewSchema = z25.object({
-  sessionId: z25.string(),
-  projectId: z25.string(),
+var discoveryPromotePreviewSchema = z26.object({
+  sessionId: z26.string(),
+  projectId: z26.string(),
   status: discoverySessionStatusSchema,
-  queriesByBucket: z25.object({
-    cited: z25.array(z25.string()),
-    aspirational: z25.array(z25.string()),
-    "wasted-surface": z25.array(z25.string())
+  queriesByBucket: z26.object({
+    cited: z26.array(z26.string()),
+    aspirational: z26.array(z26.string()),
+    "wasted-surface": z26.array(z26.string())
   }),
-  suggestedCompetitors: z25.array(discoveryCompetitorMapEntrySchema)
-});
-var discoveryPromoteResultSchema = z25.object({
-  sessionId: z25.string(),
-  projectId: z25.string(),
-  promoted: z25.object({
-    queries: z25.array(z25.string()),
-    competitors: z25.array(z25.string())
+  suggestedCompetitors: z26.array(discoveryCompetitorMapEntrySchema)
+});
+var discoveryPromoteResultSchema = z26.object({
+  sessionId: z26.string(),
+  projectId: z26.string(),
+  promoted: z26.object({
+    queries: z26.array(z26.string()),
+    competitors: z26.array(z26.string())
   }),
-  skipped: z25.object({
-    queries: z25.array(z25.string()),
-    competitors: z25.array(z25.string())
+  skipped: z26.object({
+    queries: z26.array(z26.string()),
+    competitors: z26.array(z26.string())
   })
 });
-var queryProvenanceSchema = z25.union([
-  z25.literal("cli"),
-  z25.string().regex(/^discovery:.+$/)
+var queryProvenanceSchema = z26.union([
+  z26.literal("cli"),
+  z26.string().regex(/^discovery:.+$/)
 ]);
 
 // ../contracts/src/embeddings.ts
@@ -3920,6 +3948,10 @@ var AI_PROVIDER_INFRA_DOMAINS = [
 
 export {
   __export,
+  apiKeyDtoSchema,
+  apiKeyListDtoSchema,
+  createApiKeyRequestSchema,
+  createdApiKeyDtoSchema,
   providerQuotaPolicySchema,
   ProviderNames,
   isBrowserProvider,