@ainyc/canonry 3.3.9 → 3.4.5

package/dist/{chunk-24C7RMIS.js → chunk-5OYYYY4I.js}

@@ -1,3 +1,17 @@
+import {
+  AGENT_MEMORY_KEY_MAX_LENGTH,
+  AGENT_MEMORY_VALUE_MAX_BYTES,
+  competitorBatchRequestSchema,
+  keywordBatchRequestSchema,
+  keywordGenerateRequestSchema,
+  notificationCreateRequestSchema,
+  notificationEventSchema,
+  projectConfigSchema,
+  projectUpsertRequestSchema,
+  runTriggerRequestSchema,
+  scheduleUpsertRequestSchema
+} from "./chunk-D4YFX3X4.js";
+
 // src/config.ts
 import fs from "fs";
 import path from "path";
@@ -238,1843 +252,6 @@ function printCliError(err, format) {
   console.error("An unexpected error occurred");
 }
 
-// ../contracts/src/errors.ts
-var AppError = class extends Error {
-  code;
-  statusCode;
-  details;
-  constructor(code, message, statusCode, details) {
-    super(message);
-    this.name = "AppError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-  }
-  toJSON() {
-    return {
-      error: {
-        code: this.code,
-        message: this.message,
-        ...this.details ? { details: this.details } : {}
-      }
-    };
-  }
-};
-function notFound(entity, id) {
-  return new AppError("NOT_FOUND", `${entity} '${id}' not found`, 404);
-}
-function validationError(message, details) {
-  return new AppError("VALIDATION_ERROR", message, 400, details);
-}
-function authRequired() {
-  return new AppError("AUTH_REQUIRED", "Authentication required", 401);
-}
-function authInvalid() {
-  return new AppError("AUTH_INVALID", "Invalid API key", 401);
-}
-function providerError(message, details) {
-  return new AppError("PROVIDER_ERROR", message, 502, details);
-}
-function runInProgress(projectName) {
-  return new AppError("RUN_IN_PROGRESS", `A run is already in progress for '${projectName}'`, 409);
-}
-function runNotCancellable(runId, status) {
-  return new AppError("RUN_NOT_CANCELLABLE", `Run '${runId}' is already in terminal state '${status}' and cannot be cancelled`, 409);
-}
-function unsupportedKind(kind) {
-  return new AppError("UNSUPPORTED_KIND", `Kind '${kind}' is not supported in this version`, 400);
-}
-function notImplemented(message) {
-  return new AppError("NOT_IMPLEMENTED", message, 501);
-}
-function deliveryFailed(message) {
-  return new AppError("DELIVERY_FAILED", message, 502);
-}
-function agentBusy(projectName) {
-  return new AppError(
-    "AGENT_BUSY",
-    `Aero is already running a turn for '${projectName}'. Retry after the current turn settles.`,
-    409
-  );
-}
-function missingDependency(message, details) {
-  return new AppError("MISSING_DEPENDENCY", message, 422, details);
-}
-function internalError(message, details) {
-  return new AppError("INTERNAL_ERROR", message, 500, details);
-}
-
-// ../contracts/src/run.ts
-import { z as z2 } from "zod";
-
-// ../contracts/src/provider.ts
-import { z } from "zod";
-var providerQuotaPolicySchema = z.object({
-  maxConcurrency: z.number().int().positive(),
-  maxRequestsPerMinute: z.number().int().positive(),
-  maxRequestsPerDay: z.number().int().positive()
-});
-var ProviderNames = {
-  gemini: "gemini",
-  openai: "openai",
-  claude: "claude",
-  perplexity: "perplexity",
-  local: "local",
-  cdpChatgpt: "cdp:chatgpt"
-};
-var providerNameSchema = z.string().min(1);
-var apiProviderNameSchema = z.string().min(1);
-function isBrowserProvider(name) {
-  return name.startsWith("cdp:");
-}
-var CDP_TARGETS = ["cdp:chatgpt"];
-function resolveProviderInput(input) {
-  const lower = input.trim().toLowerCase();
-  if (lower === "cdp") {
-    return [...CDP_TARGETS];
-  }
-  return lower ? [lower] : [];
-}
-var locationContextSchema = z.object({
-  label: z.string().min(1),
-  city: z.string().min(1),
-  region: z.string().min(1),
-  country: z.string().length(2),
-  timezone: z.string().optional()
-});
-
-// ../contracts/src/run.ts
-var runStatusSchema = z2.enum(["queued", "running", "completed", "partial", "failed", "cancelled"]);
-var RunStatuses = runStatusSchema.enum;
-var runKindSchema = z2.enum([
-  "answer-visibility",
-  "site-audit",
-  "gsc-sync",
-  "inspect-sitemap",
-  "ga-sync",
-  "bing-inspect",
-  "bing-inspect-sitemap",
-  "backlink-extract"
-]);
-var RunKinds = runKindSchema.enum;
-var runTriggerSchema = z2.enum(["manual", "scheduled", "config-apply"]);
-var RunTriggers = runTriggerSchema.enum;
-var citationStateSchema = z2.enum(["cited", "not-cited"]);
-var CitationStates = citationStateSchema.enum;
-var visibilityStateSchema = z2.enum(["visible", "not-visible"]);
-var VisibilityStates = visibilityStateSchema.enum;
-var computedTransitionSchema = z2.enum(["new", "cited", "lost", "emerging", "not-cited"]);
-var ComputedTransitions = computedTransitionSchema.enum;
-var runTriggerRequestSchema = z2.object({
-  kind: z2.literal(RunKinds["answer-visibility"]).optional(),
-  trigger: z2.literal(RunTriggers.manual).optional(),
-  providers: z2.array(providerNameSchema).optional(),
-  location: z2.string().min(1).optional(),
-  allLocations: z2.boolean().optional(),
-  noLocation: z2.boolean().optional()
-}).refine(
-  (data) => Number(Boolean(data.location)) + Number(Boolean(data.allLocations)) + Number(Boolean(data.noLocation)) <= 1,
-  { message: 'Only one of "location", "allLocations", or "noLocation" may be provided' }
-);
-var runProviderErrorSchema = z2.object({
-  /** Human-readable error message (best-effort extracted from `raw.error.message` / `raw.message`, otherwise the raw text with any `[provider-X]` prefix stripped). */
-  message: z2.string(),
-  /** Original provider response payload, if the underlying error body parsed as JSON. Use this for structured fields like HTTP status, error code, etc. */
-  raw: z2.unknown().optional()
-});
-var runErrorSchema = z2.object({
-  /** Top-level message for runs that failed without a per-provider error (e.g. user cancellation, internal scheduling failures). */
-  message: z2.string().optional(),
-  /** Per-provider errors for visibility-sweep runs that had at least one provider fail. */
-  providers: z2.record(z2.string(), runProviderErrorSchema).optional()
-});
-var runDtoSchema = z2.object({
-  id: z2.string(),
-  projectId: z2.string(),
-  kind: runKindSchema,
-  status: runStatusSchema,
-  trigger: runTriggerSchema.default("manual"),
-  location: z2.string().nullable().optional(),
-  startedAt: z2.string().nullable().optional(),
-  finishedAt: z2.string().nullable().optional(),
-  error: runErrorSchema.nullable().optional(),
-  createdAt: z2.string()
-});
-var PROVIDER_PREFIX = /^\[provider-[a-zA-Z0-9_-]+\]\s+/;
-function parseProviderErrorMessage(msg) {
-  const stripped = msg.replace(PROVIDER_PREFIX, "");
-  try {
-    const raw = JSON.parse(stripped);
-    if (raw && typeof raw === "object") {
-      const inner = raw;
-      const fromErrorMessage = typeof inner.error?.message === "string" ? inner.error.message : void 0;
-      const fromMessage = typeof inner.message === "string" ? inner.message : void 0;
-      return { message: fromErrorMessage ?? fromMessage ?? stripped, raw };
-    }
-  } catch {
-  }
-  return { message: stripped };
-}
-function parseRunError(raw) {
-  if (!raw) return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return { message: raw };
-  }
-  if (!parsed || typeof parsed !== "object") {
-    return { message: raw };
-  }
-  const obj = parsed;
-  const hasProviders = obj.providers && typeof obj.providers === "object";
-  const hasMessage = typeof obj.message === "string";
-  if (hasProviders || hasMessage) {
-    return parsed;
-  }
-  const providers = {};
-  for (const [name, val] of Object.entries(obj)) {
-    providers[name] = parseProviderErrorMessage(typeof val === "string" ? val : JSON.stringify(val));
-  }
-  return { providers };
-}
-function buildRunErrorFromMessages(messages) {
-  const providers = {};
-  for (const [name, msg] of messages) {
-    providers[name] = parseProviderErrorMessage(msg);
-  }
-  return { providers };
-}
-function serializeRunError(err) {
-  return JSON.stringify(err);
-}
-function formatRunErrorOneLine(err) {
-  if (err.providers) {
-    const entries = Object.entries(err.providers);
-    if (entries.length === 1) {
-      const [provider, detail] = entries[0];
-      return `${provider}: ${detail.message}`;
-    }
-    if (entries.length > 1) {
-      return entries.map(([p, d]) => `${p}: ${d.message}`).join(" \u2022 ");
-    }
-  }
-  return err.message ?? "Run failed.";
-}
-var groundingSourceSchema = z2.object({
-  uri: z2.string(),
-  title: z2.string()
-});
-var querySnapshotDtoSchema = z2.object({
-  id: z2.string(),
-  runId: z2.string(),
-  keywordId: z2.string(),
-  keyword: z2.string().optional(),
-  provider: providerNameSchema,
-  citationState: citationStateSchema,
-  answerMentioned: z2.boolean().optional(),
-  visibilityState: visibilityStateSchema.optional(),
-  transition: computedTransitionSchema.optional(),
-  answerText: z2.string().nullable().optional(),
-  citedDomains: z2.array(z2.string()).default([]),
-  competitorOverlap: z2.array(z2.string()).default([]),
-  recommendedCompetitors: z2.array(z2.string()).default([]),
-  matchedTerms: z2.array(z2.string()).default([]),
-  groundingSources: z2.array(groundingSourceSchema).default([]),
-  searchQueries: z2.array(z2.string()).default([]),
-  model: z2.string().nullable().optional(),
-  location: z2.string().nullable().optional(),
-  createdAt: z2.string()
-});
-var snapshotListResponseSchema = z2.object({
-  snapshots: z2.array(querySnapshotDtoSchema),
-  total: z2.number().int().nonnegative()
-});
-var snapshotDiffRowSchema = z2.object({
-  keywordId: z2.string().nullable(),
-  keyword: z2.string().nullable(),
-  run1State: citationStateSchema.nullable(),
-  run2State: citationStateSchema.nullable(),
-  run1AnswerMentioned: z2.boolean().nullable(),
-  run2AnswerMentioned: z2.boolean().nullable(),
-  run1VisibilityState: visibilityStateSchema.nullable(),
-  run2VisibilityState: visibilityStateSchema.nullable(),
-  changed: z2.boolean(),
-  visibilityChanged: z2.boolean()
-});
-var snapshotDiffResponseSchema = z2.object({
-  run1: z2.string(),
-  run2: z2.string(),
-  diff: z2.array(snapshotDiffRowSchema)
-});
-var runDetailDtoSchema = runDtoSchema.extend({
-  snapshots: z2.array(querySnapshotDtoSchema).optional()
-});
-var latestProjectRunDtoSchema = z2.object({
-  totalRuns: z2.number().int().nonnegative(),
-  run: runDetailDtoSchema.nullable()
-});
-var auditLogEntrySchema = z2.object({
-  id: z2.string(),
-  projectId: z2.string().nullable().optional(),
-  actor: z2.string(),
-  action: z2.string(),
-  entityType: z2.string(),
-  entityId: z2.string().nullable().optional(),
-  diff: z2.unknown().optional(),
-  createdAt: z2.string()
-});
-
-// ../contracts/src/config-schema.ts
-import { z as z5 } from "zod";
-
-// ../contracts/src/notification.ts
-import { z as z3 } from "zod";
-var notificationEventSchema = z3.enum([
-  "citation.lost",
-  "citation.gained",
-  "run.completed",
-  "run.failed",
-  "insight.critical",
-  "insight.high"
-]);
-var notificationDtoSchema = z3.object({
-  id: z3.string(),
-  projectId: z3.string(),
-  channel: z3.literal("webhook"),
-  url: z3.string().url(),
-  urlDisplay: z3.string(),
-  urlHost: z3.string(),
-  events: z3.array(notificationEventSchema),
-  enabled: z3.boolean().default(true),
-  /** Opaque tag identifying the creator (e.g. `"agent"` for Aero webhooks). */
-  source: z3.string().optional(),
-  webhookSecret: z3.string().optional(),
-  createdAt: z3.string(),
-  updatedAt: z3.string()
-});
-var notificationCreateRequestSchema = z3.object({
-  channel: z3.literal("webhook"),
-  url: z3.string().url(),
-  events: z3.array(notificationEventSchema).min(1),
-  source: z3.string().optional()
-});
-
-// ../contracts/src/project.ts
-import { z as z4 } from "zod";
-var configSourceSchema = z4.enum(["cli", "api", "config-file"]);
-function findDuplicateLocationLabels(locations) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const location of locations) {
-    if (seen.has(location.label)) {
-      duplicates.add(location.label);
-      continue;
-    }
-    seen.add(location.label);
-  }
-  return [...duplicates];
-}
-function hasLocationLabel(locations, label) {
-  if (!label) return true;
-  return locations.some((location) => location.label === label);
-}
-var projectUpsertRequestSchema = z4.object({
-  displayName: z4.string().min(1),
-  canonicalDomain: z4.string().min(1),
-  ownedDomains: z4.array(z4.string().min(1)).optional(),
-  country: z4.string().length(2),
-  language: z4.string().min(2),
-  tags: z4.array(z4.string()).optional(),
-  labels: z4.record(z4.string(), z4.string()).optional(),
-  providers: z4.array(providerNameSchema).optional(),
-  locations: z4.array(locationContextSchema).optional(),
-  defaultLocation: z4.string().nullable().optional(),
-  autoExtractBacklinks: z4.boolean().optional(),
-  configSource: configSourceSchema.optional()
-});
-var projectDtoSchema = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  displayName: z4.string().optional(),
-  canonicalDomain: z4.string(),
-  ownedDomains: z4.array(z4.string()).default([]),
-  country: z4.string().length(2),
-  language: z4.string().min(2),
-  tags: z4.array(z4.string()).default([]),
-  labels: z4.record(z4.string(), z4.string()).default({}),
-  locations: z4.array(locationContextSchema).default([]),
-  defaultLocation: z4.string().nullable().optional(),
-  autoExtractBacklinks: z4.boolean().default(false),
-  configSource: configSourceSchema.default("cli"),
-  configRevision: z4.number().int().positive().default(1),
-  createdAt: z4.string().optional(),
-  updatedAt: z4.string().optional()
-});
-var keywordDtoSchema = z4.object({
-  id: z4.string(),
-  keyword: z4.string(),
-  createdAt: z4.string()
-});
-var keywordBatchRequestSchema = z4.object({
-  keywords: z4.array(z4.string().trim().min(1)).min(1)
-});
-var keywordGenerateRequestSchema = z4.object({
-  provider: providerNameSchema,
-  count: z4.number().int().min(1).max(20).optional()
-});
-var competitorDtoSchema = z4.object({
-  id: z4.string(),
-  domain: z4.string(),
-  createdAt: z4.string()
-});
-var competitorBatchRequestSchema = z4.object({
-  competitors: z4.array(z4.string().trim().min(1)).min(1)
-});
-function normalizeProjectDomain(input) {
-  let domain = input.trim().toLowerCase();
-  try {
-    if (domain.includes("://")) {
-      domain = new URL(domain).hostname.toLowerCase();
-    }
-  } catch {
-  }
-  return domain.replace(/^www\./, "");
-}
-var MULTI_LABEL_PUBLIC_SUFFIXES = /* @__PURE__ */ new Set([
-  "ac.uk",
-  "co.id",
-  "co.il",
-  "co.in",
-  "co.jp",
-  "co.kr",
-  "co.nz",
-  "co.th",
-  "co.uk",
-  "co.za",
-  "com.au",
-  "com.br",
-  "com.cn",
-  "com.mx",
-  "com.ph",
-  "com.sg",
-  "com.tr",
-  "edu.au",
-  "edu.sg",
-  "gov.au",
-  "gov.uk",
-  "me.uk",
-  "ne.jp",
-  "net.au",
-  "net.br",
-  "net.cn",
-  "net.in",
-  "net.tr",
-  "or.jp",
-  "or.kr",
-  "org.au",
-  "org.br",
-  "org.in",
-  "org.nz",
-  "org.tr",
-  "org.uk",
-  "org.za"
-]);
-function registrableDomain(input) {
-  const normalized = normalizeProjectDomain(input);
-  if (!normalized) return "";
-  const hostname = normalized.split("/")[0]?.split(":")[0] ?? "";
-  if (!hostname) return "";
-  const labels = hostname.split(".").filter(Boolean);
-  if (labels.length < 2) return "";
-  if (labels.length === 2) return labels.join(".");
-  const lastTwo = labels.slice(-2).join(".");
-  if (MULTI_LABEL_PUBLIC_SUFFIXES.has(lastTwo)) {
-    return labels.length >= 3 ? labels.slice(-3).join(".") : "";
-  }
-  return labels.slice(-2).join(".");
-}
-function brandLabelFromDomain(input) {
-  const reg = registrableDomain(input);
-  if (!reg) return "";
-  return reg.split(".")[0] ?? "";
-}
-function effectiveDomains(project) {
-  const all = [project.canonicalDomain, ...project.ownedDomains ?? []];
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const d of all) {
-    const trimmed = d.trim();
-    if (!trimmed) continue;
-    const norm = normalizeProjectDomain(trimmed);
-    if (seen.has(norm)) continue;
-    seen.add(norm);
-    result.push(trimmed);
-  }
-  return result;
-}
-
-// ../contracts/src/config-schema.ts
-var configMetadataSchema = z5.object({
-  name: z5.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({})
-});
-var configScheduleSchema = z5.object({
-  preset: z5.string().optional(),
-  cron: z5.string().optional(),
-  timezone: z5.string().optional().default("UTC"),
-  providers: z5.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()
-  }).optional(),
-  syncSchedule: z5.object({
-    preset: z5.string().optional(),
-    cron: z5.string().optional()
-  }).optional()
-}).optional();
-var configSpecSchema = z5.object({
-  displayName: z5.string().min(1),
-  canonicalDomain: z5.string().min(1),
-  ownedDomains: z5.array(z5.string().min(1)).optional().default([]),
-  country: z5.string().length(2),
-  language: z5.string().min(2),
-  keywords: z5.array(z5.string().min(1)).optional().default([]),
-  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(),
-  schedule: configScheduleSchema,
-  notifications: z5.array(configNotificationSchema).optional().default([]),
-  google: configGoogleSchema,
-  autoExtractBacklinks: z5.boolean().optional().default(false)
-}).superRefine((spec, ctx) => {
-  const duplicateLabels = findDuplicateLocationLabels(spec.locations);
-  if (duplicateLabels.length > 0) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`,
-      path: ["locations"]
-    });
-  }
-  if (!hasLocationLabel(spec.locations, spec.defaultLocation)) {
-    ctx.addIssue({
-      code: "custom",
-      message: `defaultLocation "${spec.defaultLocation}" must match a configured location label`,
-      path: ["defaultLocation"]
-    });
-  }
-});
-var projectConfigSchema = z5.object({
-  apiVersion: z5.literal("canonry/v1"),
-  kind: z5.literal("Project"),
-  metadata: configMetadataSchema,
-  spec: configSpecSchema
-});
-
-// ../contracts/src/google.ts
-import { z as z6 } from "zod";
-var googleConnectionTypeSchema = z6.enum(["gsc", "ga4"]);
-var googleConnectionDtoSchema = z6.object({
-  id: z6.string(),
-  domain: z6.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 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([]),
-  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()
-  }),
-  lastInspectedAt: 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 gscCoverageSnapshotDtoSchema = z6.object({
-  date: z6.string(),
-  indexed: z6.number(),
-  notIndexed: z6.number(),
-  reasonBreakdown: z6.record(z6.string(), z6.number()).default({})
-});
-
-// ../contracts/src/bing.ts
-import { z as z7 } from "zod";
-var bingConnectionDtoSchema = z7.object({
-  id: z7.string(),
-  domain: z7.string(),
-  siteUrl: z7.string().nullable().optional(),
-  createdAt: z7.string(),
-  updatedAt: z7.string()
-});
-var bingUrlInspectionDtoSchema = z7.object({
-  id: z7.string(),
-  url: z7.string(),
-  httpCode: z7.number().nullable().optional(),
-  inIndex: z7.boolean().nullable().optional(),
-  lastCrawledDate: z7.string().nullable().optional(),
-  inIndexDate: z7.string().nullable().optional(),
-  inspectedAt: z7.string(),
-  // Fields derived from GetUrlInfo response (more reliable than InIndex)
-  documentSize: z7.number().nullable().optional(),
-  anchorCount: z7.number().nullable().optional(),
-  discoveryDate: z7.string().nullable().optional()
-});
-var bingCoverageSummaryDtoSchema = z7.object({
-  summary: z7.object({
-    total: z7.number(),
-    indexed: z7.number(),
-    notIndexed: z7.number(),
-    unknown: z7.number().optional(),
-    percentage: z7.number()
-  }),
-  lastInspectedAt: z7.string().nullable(),
-  indexed: z7.array(bingUrlInspectionDtoSchema).default([]),
-  notIndexed: z7.array(bingUrlInspectionDtoSchema).default([]),
-  unknown: z7.array(bingUrlInspectionDtoSchema).default([]).optional()
-});
-var bingKeywordStatsDtoSchema = z7.object({
-  query: z7.string(),
-  impressions: z7.number(),
-  clicks: z7.number(),
-  ctr: z7.number(),
-  averagePosition: z7.number()
-});
-var bingCoverageSnapshotDtoSchema = z7.object({
-  date: z7.string(),
-  indexed: z7.number(),
-  notIndexed: z7.number(),
-  unknown: z7.number()
-});
-var bingSubmitResultDtoSchema = z7.object({
-  url: z7.string(),
-  status: z7.enum(["success", "error"]),
-  submittedAt: z7.string(),
-  error: z7.string().optional()
-});
-
-// ../contracts/src/wordpress.ts
-import { z as z8 } from "zod";
-var wordpressEnvSchema = z8.enum(["live", "staging"]);
-var wordpressConnectionDtoSchema = z8.object({
-  projectName: z8.string(),
-  url: z8.string(),
-  stagingUrl: z8.string().optional(),
-  username: z8.string(),
-  defaultEnv: wordpressEnvSchema,
-  createdAt: z8.string(),
-  updatedAt: z8.string()
-});
-var wordpressSiteStatusDtoSchema = z8.object({
-  url: z8.string(),
-  reachable: z8.boolean(),
-  pageCount: z8.number().nullable().optional(),
-  version: z8.string().nullable().optional(),
-  error: z8.string().nullable().optional(),
-  plugins: z8.array(z8.string()).optional(),
-  authenticatedUser: z8.object({
-    id: z8.number(),
-    slug: z8.string()
-  }).nullable().optional()
-});
-var wordpressStatusDtoSchema = z8.object({
-  connected: z8.boolean(),
-  projectName: z8.string(),
-  defaultEnv: wordpressEnvSchema,
-  live: wordpressSiteStatusDtoSchema.nullable(),
-  staging: wordpressSiteStatusDtoSchema.nullable(),
-  adminUrl: z8.string().nullable().optional()
-});
-var wordpressPageSummaryDtoSchema = z8.object({
-  id: z8.number(),
-  slug: z8.string(),
-  title: z8.string(),
-  status: z8.string(),
-  modifiedAt: z8.string().nullable().optional(),
-  link: z8.string().nullable().optional()
-});
-var wordpressSeoStateDtoSchema = z8.object({
-  title: z8.string().nullable(),
-  description: z8.string().nullable(),
-  noindex: z8.boolean().nullable(),
-  writable: z8.boolean().default(false),
-  writeTargets: z8.array(z8.string()).default([])
-});
-var wordpressSchemaBlockDtoSchema = z8.object({
-  type: z8.string(),
-  json: z8.record(z8.string(), z8.unknown())
-});
-var wordpressPageDetailDtoSchema = wordpressPageSummaryDtoSchema.extend({
-  env: wordpressEnvSchema,
-  content: z8.string(),
-  seo: wordpressSeoStateDtoSchema,
-  schemaBlocks: z8.array(wordpressSchemaBlockDtoSchema).default([])
-});
-var wordpressDiffPageDtoSchema = wordpressPageDetailDtoSchema.extend({
-  contentHash: z8.string(),
-  contentSnippet: z8.string()
-});
-var wordpressManualAssistDtoSchema = z8.object({
-  manualRequired: z8.literal(true),
-  targetUrl: z8.string(),
-  adminUrl: z8.string().nullable().optional(),
-  content: z8.string(),
-  nextSteps: z8.array(z8.string()).default([])
-});
-var wordpressAuditIssueDtoSchema = z8.object({
-  slug: z8.string(),
-  severity: z8.enum(["high", "medium", "low"]),
-  code: z8.enum([
-    "noindex",
-    "missing-seo-title",
-    "missing-meta-description",
-    "missing-schema",
-    "thin-content"
-  ]),
-  message: z8.string()
-});
-var wordpressAuditPageDtoSchema = z8.object({
-  slug: z8.string(),
-  title: z8.string(),
-  status: z8.string(),
-  wordCount: z8.number(),
-  seo: wordpressSeoStateDtoSchema,
-  schemaPresent: z8.boolean(),
-  issues: z8.array(wordpressAuditIssueDtoSchema).default([])
-});
-var wordpressBulkMetaEntryResultDtoSchema = z8.object({
-  slug: z8.string(),
-  status: z8.enum(["applied", "skipped", "manual"]),
-  error: z8.string().optional(),
-  manualAssist: wordpressManualAssistDtoSchema.optional()
-});
-var wordpressBulkMetaResultDtoSchema = z8.object({
-  env: wordpressEnvSchema,
-  strategy: z8.enum(["plugin", "manual"]),
-  results: z8.array(wordpressBulkMetaEntryResultDtoSchema)
-});
-var wordpressSchemaDeployEntryResultDtoSchema = z8.object({
-  slug: z8.string(),
-  status: z8.enum(["deployed", "stripped", "skipped", "failed"]),
-  schemasInjected: z8.array(z8.string()).optional(),
-  manualAssist: wordpressManualAssistDtoSchema.optional(),
-  error: z8.string().optional()
-});
-var wordpressSchemaDeployResultDtoSchema = z8.object({
-  env: wordpressEnvSchema,
-  results: z8.array(wordpressSchemaDeployEntryResultDtoSchema)
-});
-var wordpressSchemaStatusPageDtoSchema = z8.object({
-  slug: z8.string(),
-  title: z8.string(),
-  canonrySchemas: z8.array(z8.string()),
-  thirdPartySchemas: z8.array(z8.string()),
-  hasCanonrySchema: z8.boolean()
-});
-var wordpressSchemaStatusResultDtoSchema = z8.object({
-  env: wordpressEnvSchema,
-  pages: z8.array(wordpressSchemaStatusPageDtoSchema)
-});
-var wordpressOnboardStepDtoSchema = z8.object({
-  name: z8.string(),
-  status: z8.enum(["completed", "skipped", "failed"]),
-  summary: z8.string().optional(),
-  error: z8.string().optional()
-});
-var wordpressOnboardResultDtoSchema = z8.object({
-  projectName: z8.string(),
-  steps: z8.array(wordpressOnboardStepDtoSchema)
-});
-var wordpressDiffDtoSchema = z8.object({
-  slug: z8.string(),
-  live: wordpressDiffPageDtoSchema,
-  staging: wordpressDiffPageDtoSchema,
-  hasDifferences: z8.boolean(),
-  differences: z8.object({
-    title: z8.boolean(),
-    slug: z8.boolean(),
-    content: z8.boolean(),
-    seoTitle: z8.boolean(),
-    seoDescription: z8.boolean(),
-    noindex: z8.boolean(),
-    schema: z8.boolean()
-  })
-});
-
-// ../contracts/src/providers.ts
-var ProviderIds = {
-  claude: "claude",
-  openai: "openai",
-  gemini: "gemini",
-  perplexity: "perplexity",
-  local: "local",
-  cdpChatgpt: "cdp:chatgpt",
-  zai: "zai"
-};
-var PROVIDER_IDS = Object.values(ProviderIds);
-var SweepProviderIds = {
-  claude: ProviderIds.claude,
-  openai: ProviderIds.openai,
-  gemini: ProviderIds.gemini,
-  perplexity: ProviderIds.perplexity,
-  local: ProviderIds.local,
-  cdpChatgpt: ProviderIds.cdpChatgpt
-};
-var SWEEP_PROVIDER_IDS = Object.values(SweepProviderIds);
-var AgentProviderIds = {
-  claude: ProviderIds.claude,
-  openai: ProviderIds.openai,
-  gemini: ProviderIds.gemini,
-  zai: ProviderIds.zai
-};
-var AGENT_PROVIDER_IDS = Object.values(AgentProviderIds);
-function isAgentProviderId(value) {
-  return AGENT_PROVIDER_IDS.includes(value);
-}
-
-// ../contracts/src/snapshot.ts
-import { z as z9 } from "zod";
-var snapshotAccuracySchema = z9.enum(["yes", "no", "unknown", "not-mentioned"]);
-var snapshotRequestSchema = z9.object({
-  companyName: z9.string().min(1),
-  domain: z9.string().min(1),
-  phrases: z9.array(z9.string().min(1)).optional().default([]),
-  competitors: z9.array(z9.string().min(1)).optional().default([])
-});
-var snapshotCompetitorEntrySchema = z9.object({
-  name: z9.string(),
-  count: z9.number().int().nonnegative()
-});
-var snapshotAuditFactorSchema = z9.object({
-  id: z9.string(),
-  name: z9.string(),
-  weight: z9.number(),
-  score: z9.number(),
-  grade: z9.string(),
-  status: z9.enum(["pass", "partial", "fail"]),
-  findings: z9.array(z9.object({
-    type: z9.string(),
-    message: z9.string()
-  })).default([]),
-  recommendations: z9.array(z9.string()).default([])
-});
-var snapshotAuditSchema = z9.object({
-  url: z9.string(),
-  finalUrl: z9.string(),
-  auditedAt: z9.string(),
-  overallScore: z9.number(),
-  overallGrade: z9.string(),
-  summary: z9.string(),
-  factors: z9.array(snapshotAuditFactorSchema).default([])
-});
-var snapshotProfileSchema = z9.object({
-  industry: z9.string(),
-  summary: z9.string(),
-  services: z9.array(z9.string()).default([]),
-  categoryTerms: z9.array(z9.string()).default([])
-});
-var snapshotProviderResultSchema = z9.object({
-  provider: z9.string(),
-  displayName: z9.string(),
-  model: z9.string().nullable().optional(),
-  mentioned: z9.boolean(),
-  cited: z9.boolean(),
-  describedAccurately: snapshotAccuracySchema,
-  accuracyNotes: z9.string().nullable().optional(),
-  incorrectClaims: z9.array(z9.string()).default([]),
-  recommendedCompetitors: z9.array(z9.string()).default([]),
-  citedDomains: z9.array(z9.string()).default([]),
-  groundingSources: z9.array(groundingSourceSchema).default([]),
-  searchQueries: z9.array(z9.string()).default([]),
-  answerText: z9.string(),
-  error: z9.string().nullable().optional()
-});
-var snapshotQueryResultSchema = z9.object({
-  phrase: z9.string(),
-  providerResults: z9.array(snapshotProviderResultSchema).default([])
-});
-var snapshotSummarySchema = z9.object({
-  totalQueries: z9.number().int().nonnegative(),
-  totalProviders: z9.number().int().nonnegative(),
-  totalComparisons: z9.number().int().nonnegative(),
-  mentionCount: z9.number().int().nonnegative(),
-  citationCount: z9.number().int().nonnegative(),
-  topCompetitors: z9.array(snapshotCompetitorEntrySchema).default([]),
-  visibilityGap: z9.string(),
-  whatThisMeans: z9.array(z9.string()).default([]),
-  recommendedActions: z9.array(z9.string()).default([])
-});
-var snapshotReportSchema = z9.object({
-  companyName: z9.string(),
-  domain: z9.string(),
-  homepageUrl: z9.string(),
-  generatedAt: z9.string(),
-  phrases: z9.array(z9.string()).default([]),
-  competitors: z9.array(z9.string()).default([]),
-  profile: snapshotProfileSchema,
-  audit: snapshotAuditSchema,
-  queryResults: z9.array(snapshotQueryResultSchema).default([]),
-  summary: snapshotSummarySchema
-});
-
-// ../contracts/src/schedule.ts
-import { z as z10 } from "zod";
-var scheduleDtoSchema = z10.object({
-  id: z10.string(),
-  projectId: z10.string(),
-  cronExpr: z10.string(),
-  preset: z10.string().nullable().optional(),
-  timezone: z10.string().default("UTC"),
-  enabled: z10.boolean().default(true),
-  providers: z10.array(providerNameSchema).default([]),
-  lastRunAt: z10.string().nullable().optional(),
-  nextRunAt: z10.string().nullable().optional(),
-  createdAt: z10.string(),
-  updatedAt: z10.string()
-});
-var scheduleUpsertRequestSchema = z10.object({
-  preset: z10.string().optional(),
-  cron: z10.string().optional(),
-  timezone: z10.string().optional().default("UTC"),
-  enabled: z10.boolean().optional().default(true),
-  providers: z10.array(providerNameSchema).optional().default([])
-}).refine(
-  (data) => data.preset && !data.cron || !data.preset && data.cron,
-  { message: 'Exactly one of "preset" or "cron" must be provided' }
-);
-
-// ../contracts/src/analytics.ts
-import { z as z11 } from "zod";
-var visibilityMetricModeSchema = z11.enum(["mentioned", "cited"]);
-var VisibilityMetricModes = visibilityMetricModeSchema.enum;
-function parseWindow(value) {
-  if (value === "7d" || value === "30d" || value === "90d" || value === "all") return value;
-  return "all";
-}
-function windowCutoff(window) {
-  if (window === "all") return null;
-  const days = window === "7d" ? 7 : window === "30d" ? 30 : 90;
-  const d = /* @__PURE__ */ new Date();
-  d.setDate(d.getDate() - days);
-  return d.toISOString();
-}
-
-// ../contracts/src/source-categories.ts
-var SOURCE_CATEGORY_RULES = [
-  // Forums
-  { pattern: "reddit.com", category: "forum", label: "Reddit" },
-  { pattern: "quora.com", category: "forum", label: "Quora" },
-  { pattern: "stackexchange.com", category: "forum", label: "Stack Exchange" },
-  { pattern: "stackoverflow.com", category: "forum", label: "Stack Overflow" },
-  { pattern: "discourse.org", category: "forum", label: "Discourse" },
-  // Social
-  { pattern: "linkedin.com", category: "social", label: "LinkedIn" },
-  { pattern: "twitter.com", category: "social", label: "X (Twitter)" },
-  { pattern: "x.com", category: "social", label: "X (Twitter)" },
-  { pattern: "facebook.com", category: "social", label: "Facebook" },
-  { pattern: "instagram.com", category: "social", label: "Instagram" },
-  { pattern: "threads.net", category: "social", label: "Threads" },
-  { pattern: "pinterest.com", category: "social", label: "Pinterest" },
-  { pattern: "tiktok.com", category: "social", label: "TikTok" },
-  // Video
-  { pattern: "youtube.com", category: "video", label: "YouTube" },
-  { pattern: "youtu.be", category: "video", label: "YouTube" },
-  { pattern: "vimeo.com", category: "video", label: "Vimeo" },
-  // News
-  { pattern: "nytimes.com", category: "news", label: "NY Times" },
-  { pattern: "bbc.com", category: "news", label: "BBC" },
-  { pattern: "bbc.co.uk", category: "news", label: "BBC" },
-  { pattern: "cnn.com", category: "news", label: "CNN" },
-  { pattern: "reuters.com", category: "news", label: "Reuters" },
-  { pattern: "apnews.com", category: "news", label: "AP News" },
-  { pattern: "theguardian.com", category: "news", label: "The Guardian" },
-  { pattern: "washingtonpost.com", category: "news", label: "Washington Post" },
-  { pattern: "wsj.com", category: "news", label: "WSJ" },
-  { pattern: "forbes.com", category: "news", label: "Forbes" },
-  { pattern: "techcrunch.com", category: "news", label: "TechCrunch" },
-  { pattern: "theverge.com", category: "news", label: "The Verge" },
-  { pattern: "wired.com", category: "news", label: "Wired" },
-  { pattern: "arstechnica.com", category: "news", label: "Ars Technica" },
-  // Reference
-  { pattern: "wikipedia.org", category: "reference", label: "Wikipedia" },
-  { pattern: "wikimedia.org", category: "reference", label: "Wikimedia" },
-  { pattern: "britannica.com", category: "reference", label: "Britannica" },
-  { pattern: "merriam-webster.com", category: "reference", label: "Merriam-Webster" },
-  // Blog / Content platforms
-  { pattern: "medium.com", category: "blog", label: "Medium" },
-  { pattern: "substack.com", category: "blog", label: "Substack" },
-  { pattern: "dev.to", category: "blog", label: "DEV Community" },
-  { pattern: "hashnode.dev", category: "blog", label: "Hashnode" },
-  { pattern: "wordpress.com", category: "blog", label: "WordPress" },
-  { pattern: "blogger.com", category: "blog", label: "Blogger" },
-  { pattern: "hubspot.com", category: "blog", label: "HubSpot" },
-  // E-commerce
-  { pattern: "amazon.com", category: "ecommerce", label: "Amazon" },
-  { pattern: "amazon.co.uk", category: "ecommerce", label: "Amazon UK" },
-  { pattern: "shopify.com", category: "ecommerce", label: "Shopify" },
-  { pattern: "ebay.com", category: "ecommerce", label: "eBay" },
-  // Academic
-  { pattern: "scholar.google.com", category: "academic", label: "Google Scholar" },
-  { pattern: "arxiv.org", category: "academic", label: "arXiv" },
-  { pattern: "pubmed.ncbi.nlm.nih.gov", category: "academic", label: "PubMed" },
-  { pattern: "researchgate.net", category: "academic", label: "ResearchGate" },
-  { pattern: ".edu", category: "academic", label: "Academic (.edu)" }
-];
-var CATEGORY_LABELS = {
-  social: "Social Media",
-  forum: "Forums & Q&A",
-  news: "News & Media",
-  reference: "Reference",
-  blog: "Blogs & Content",
-  ecommerce: "E-commerce",
-  video: "Video",
-  academic: "Academic",
-  other: "Other"
-};
-function categorizeSource(uri) {
-  let domain;
-  try {
-    const url = new URL(uri.startsWith("http") ? uri : `https://${uri}`);
-    domain = url.hostname.replace(/^www\./, "");
-  } catch {
-    domain = uri.replace(/^https?:\/\//, "").replace(/^www\./, "").split("/")[0] ?? uri;
-  }
-  const domainLower = domain.toLowerCase();
-  for (const rule of SOURCE_CATEGORY_RULES) {
-    if (domainLower === rule.pattern || domainLower.endsWith(`.${rule.pattern}`) || rule.pattern.startsWith(".") && domainLower.endsWith(rule.pattern)) {
-      return { category: rule.category, label: rule.label, domain };
-    }
-  }
-  return { category: "other", label: CATEGORY_LABELS.other, domain };
-}
-function categoryLabel(category) {
-  return CATEGORY_LABELS[category];
-}
-
-// ../contracts/src/ga.ts
-import { z as z12 } from "zod";
-var ga4ConnectionDtoSchema = z12.object({
-  id: z12.string(),
-  projectId: z12.string(),
-  propertyId: z12.string(),
-  clientEmail: z12.string(),
-  connected: z12.boolean(),
-  createdAt: z12.string(),
-  updatedAt: z12.string()
-});
-var ga4TrafficSnapshotDtoSchema = z12.object({
-  date: z12.string(),
-  landingPage: z12.string(),
-  sessions: z12.number(),
-  organicSessions: z12.number(),
-  users: z12.number()
-});
-var ga4SourceDimensionSchema = z12.enum(["session", "first_user", "manual_utm"]);
-var ga4AiReferralDtoSchema = z12.object({
-  source: z12.string(),
-  medium: z12.string(),
-  sessions: z12.number(),
-  users: z12.number(),
-  sourceDimension: ga4SourceDimensionSchema
-});
-var ga4AiReferralLandingPageDtoSchema = z12.object({
-  source: z12.string(),
-  medium: z12.string(),
-  sourceDimension: ga4SourceDimensionSchema,
-  landingPage: z12.string(),
-  sessions: z12.number(),
-  users: z12.number()
-});
-var ga4SocialReferralDtoSchema = z12.object({
-  source: z12.string(),
-  medium: z12.string(),
-  sessions: z12.number(),
-  users: z12.number(),
-  /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z12.string()
-});
-var ga4TrafficSummaryDtoSchema = z12.object({
-  totalSessions: z12.number(),
-  totalOrganicSessions: z12.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: z12.number(),
-  totalUsers: z12.number(),
-  topPages: z12.array(z12.object({
-    landingPage: z12.string(),
-    sessions: z12.number(),
-    organicSessions: z12.number(),
-    /** Per-page Direct-channel sessions. 0 for legacy rows. */
-    directSessions: z12.number(),
-    users: z12.number()
-  })),
-  aiReferrals: z12.array(ga4AiReferralDtoSchema),
-  aiReferralLandingPages: z12.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: z12.number(),
-  /** Deduped AI user total: MAX(users) per date+source+medium across attribution dimensions, then summed. */
-  aiUsersDeduped: z12.number(),
-  /** AI sessions whose CURRENT sessionSource matched an AI engine. Disjoint from Direct/Organic/Social — safe for the channel breakdown. */
-  aiSessionsBySession: z12.number(),
-  /** AI users whose CURRENT sessionSource matched an AI engine. Disjoint from Direct/Organic/Social — safe for the channel breakdown. */
-  aiUsersBySession: z12.number(),
-  socialReferrals: z12.array(ga4SocialReferralDtoSchema),
-  /** Total social sessions (session-scoped, no cross-dimension dedup needed). */
-  socialSessions: z12.number(),
-  /** Total social users (session-scoped, no cross-dimension dedup needed). */
-  socialUsers: z12.number(),
-  /** Organic sessions as a percentage of total sessions (0–100, rounded). */
-  organicSharePct: z12.number(),
-  /** Deduped AI sessions as a percentage of total sessions (0–100, rounded). Cross-cutting: can overlap with Direct/Organic/Social. */
-  aiSharePct: z12.number(),
-  /** Session-source-only AI sessions as a percentage of total sessions (0–100, rounded). Disjoint from Direct/Organic/Social. */
-  aiSharePctBySession: z12.number(),
-  /** Direct-channel sessions as a percentage of total sessions (0–100, rounded). */
-  directSharePct: z12.number(),
-  /** Social sessions as a percentage of total sessions (0–100, rounded). */
-  socialSharePct: z12.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: z12.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: z12.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: z12.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: z12.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: z12.string(),
-  lastSyncedAt: z12.string().nullable()
-});
-var ga4AiReferralHistoryEntrySchema = z12.object({
-  date: z12.string(),
-  source: z12.string(),
-  medium: z12.string(),
-  landingPage: z12.string(),
-  sessions: z12.number(),
-  users: z12.number(),
-  /** Which GA4 dimension this row came from: session (sessionSource), first_user (firstUserSource), or manual_utm (utm_source parameter) */
-  sourceDimension: ga4SourceDimensionSchema
-});
-var ga4SocialReferralHistoryEntrySchema = z12.object({
-  date: z12.string(),
-  source: z12.string(),
-  medium: z12.string(),
-  sessions: z12.number(),
-  users: z12.number(),
-  /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
-  channelGroup: z12.string()
-});
-var ga4SessionHistoryEntrySchema = z12.object({
-  date: z12.string(),
-  sessions: z12.number(),
-  organicSessions: z12.number(),
-  users: z12.number()
-});
-
-// ../contracts/src/answer-visibility.ts
-var GENERIC_TOKENS = /* @__PURE__ */ new Set([
-  "agency",
-  "app",
-  "company",
-  "corp",
-  "group",
-  "health",
-  "inc",
-  "llc",
-  "online",
-  "platform",
-  "services",
-  "site",
-  "solutions",
-  "software",
-  "systems",
-  "tech"
-]);
-var MIN_BRAND_KEY_LENGTH = 6;
-var BUSINESS_SUFFIXES = [
-  "incorporated",
-  "corporation",
-  "limited",
-  "company",
-  "gmbh",
-  "pllc",
-  "corp",
-  "group",
-  "llp",
-  "plc",
-  "llc",
-  "inc",
-  "ltd"
-];
-function extractAnswerMentions(answerText, displayName, domains) {
-  if (!answerText) return { mentioned: false, matchedTerms: [] };
-  const matchedTerms = [];
-  const lowerAnswer = answerText.toLowerCase();
-  for (const domain of domains) {
-    const normalizedDomain = normalizeProjectDomain(domain);
-    if (!normalizedDomain || !normalizedDomain.includes(".")) continue;
-    if (domainMentioned(lowerAnswer, normalizedDomain)) {
-      matchedTerms.push(normalizedDomain);
-    }
-  }
-  const answerNormalized = normalizeText(answerText);
-  const answerBrandKey = brandKeyFromText(answerText);
-  const normalizedCandidates = brandNormalizedCandidates(displayName);
-  const brandKeyCandidates = brandKeyCandidatesForMatch(displayName);
-  const matchesNormalized = normalizedCandidates.some(
-    (c) => new RegExp(`\\b${escapeRegExp(c)}\\b`).test(answerNormalized)
-  );
-  const matchesBrandKey = brandKeyCandidates.some(
-    (c) => c.length >= MIN_BRAND_KEY_LENGTH && answerBrandKey.includes(c)
-  );
-  if (matchesNormalized || matchesBrandKey) {
-    matchedTerms.push(displayName);
-  }
-  const tokens = collectDistinctiveTokens(displayName, domains);
-  let tokenMatches = 0;
-  const matchedTokens = [];
-  for (const token of tokens) {
-    if (new RegExp(`\\b${escapeRegExp(token)}\\b`).test(lowerAnswer)) {
-      tokenMatches++;
-      matchedTokens.push(token);
-    }
-  }
-  const tokenThresholdMet = tokens.length > 0 && (tokens.length === 1 && tokenMatches >= 1 || tokenMatches >= Math.min(2, tokens.length));
-  if (tokenThresholdMet) {
-    matchedTerms.push(...matchedTokens);
-  }
-  const unique = [...new Set(matchedTerms)];
-  const domainMatches = unique.filter((t) => t.includes("."));
-  const dedupedFinal = unique.filter((term) => {
-    if (term.includes(".")) return true;
-    return !domainMatches.some((d) => d.toLowerCase().startsWith(term.toLowerCase() + "."));
-  });
-  return { mentioned: dedupedFinal.length > 0, matchedTerms: dedupedFinal };
-}
-function determineAnswerMentioned(answerText, displayName, domains) {
-  return extractAnswerMentions(answerText, displayName, domains).mentioned;
-}
-function visibilityStateFromAnswerMentioned(answerMentioned) {
-  return answerMentioned ? "visible" : "not-visible";
-}
-function brandKeyFromText(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-function domainMentioned(lowerAnswer, normalizedDomain) {
-  const escapedDomain = escapeRegExp(normalizedDomain.toLowerCase());
-  const patterns = [
-    new RegExp(`(^|[^a-z0-9-])${escapedDomain}($|[^a-z0-9-])`),
-    new RegExp(`https?://(?:www\\.)?${escapedDomain}(?:[/:?#]|$)`),
-    new RegExp(`www\\.${escapedDomain}(?:[/:?#]|$)`)
-  ];
-  return patterns.some((pattern) => pattern.test(lowerAnswer));
-}
-function collectDistinctiveTokens(displayName, domains) {
-  const tokens = /* @__PURE__ */ new Set();
-  for (const token of extractDistinctiveTokens(displayName)) {
-    tokens.add(token);
-  }
-  for (const domain of domains) {
-    const reg = registrableDomain(domain);
-    const brand = reg ? brandLabelFromDomain(reg) : normalizeProjectDomain(domain).split("/")[0]?.split(".")[0] ?? "";
-    const token = brand.replace(/[^a-z0-9]/gi, "").toLowerCase();
-    if (isDistinctiveToken(token)) tokens.add(token);
-  }
-  return [...tokens];
-}
-function extractDistinctiveTokens(value) {
-  return normalizeText(value).split(" ").filter(isDistinctiveToken);
-}
-function isDistinctiveToken(token) {
-  if (token.length < 4) return false;
-  return !GENERIC_TOKENS.has(token);
-}
-function normalizeText(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-}
-function brandNormalizedCandidates(displayName) {
-  const original = normalizeText(displayName);
-  if (!original) return [];
-  const stripped = stripBusinessSuffix(original, " ");
-  if (!stripped || stripped === original) return [original];
-  return [original, stripped];
-}
-function brandKeyCandidatesForMatch(displayName) {
-  const original = brandKeyFromText(displayName);
-  if (!original) return [];
-  const stripped = stripBusinessSuffix(original, "");
-  return stripped && stripped !== original ? [original, stripped] : [original];
-}
-function stripBusinessSuffix(value, separator) {
-  for (const suffix of BUSINESS_SUFFIXES) {
-    const trailing = `${separator}${suffix}`;
-    if (value.endsWith(trailing) && value.length - trailing.length >= 3) {
-      return value.slice(0, -trailing.length);
-    }
-  }
-  return value;
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// ../contracts/src/agent.ts
-import { z as z13 } from "zod";
-var memorySourceSchema = z13.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 = z13.object({
-  key: z13.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
-  value: z13.string().min(1)
-});
-var agentMemoryDeleteRequestSchema = z13.object({
-  key: z13.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
-});
-
-// ../contracts/src/backlinks.ts
-import { z as z14 } from "zod";
-var ccReleaseSyncStatusSchema = z14.enum(["queued", "downloading", "querying", "ready", "failed"]);
-var CcReleaseSyncStatuses = ccReleaseSyncStatusSchema.enum;
-var ccReleaseSyncDtoSchema = z14.object({
-  id: z14.string(),
-  release: z14.string(),
-  status: ccReleaseSyncStatusSchema,
-  phaseDetail: z14.string().nullable().optional(),
-  vertexPath: z14.string().nullable().optional(),
-  edgesPath: z14.string().nullable().optional(),
-  vertexSha256: z14.string().nullable().optional(),
-  edgesSha256: z14.string().nullable().optional(),
-  vertexBytes: z14.number().int().nullable().optional(),
-  edgesBytes: z14.number().int().nullable().optional(),
-  projectsProcessed: z14.number().int().nullable().optional(),
-  domainsDiscovered: z14.number().int().nullable().optional(),
-  downloadStartedAt: z14.string().nullable().optional(),
-  downloadFinishedAt: z14.string().nullable().optional(),
-  queryStartedAt: z14.string().nullable().optional(),
-  queryFinishedAt: z14.string().nullable().optional(),
-  error: z14.string().nullable().optional(),
-  createdAt: z14.string(),
-  updatedAt: z14.string()
-});
-var backlinkDomainDtoSchema = z14.object({
-  linkingDomain: z14.string(),
-  numHosts: z14.number().int()
-});
-var backlinkSummaryDtoSchema = z14.object({
-  projectId: z14.string(),
-  release: z14.string(),
-  targetDomain: z14.string(),
-  totalLinkingDomains: z14.number().int(),
-  totalHosts: z14.number().int(),
-  top10HostsShare: z14.string(),
-  queriedAt: z14.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: z14.number().int().optional(),
-  excludedHosts: z14.number().int().optional()
-});
-var backlinkListResponseSchema = z14.object({
-  summary: backlinkSummaryDtoSchema.nullable(),
-  total: z14.number().int(),
-  rows: z14.array(backlinkDomainDtoSchema)
-});
-var backlinkHistoryEntrySchema = z14.object({
-  release: z14.string(),
-  totalLinkingDomains: z14.number().int(),
-  totalHosts: z14.number().int(),
-  top10HostsShare: z14.string(),
-  queriedAt: z14.string()
-});
-var backlinksInstallStatusDtoSchema = z14.object({
-  duckdbInstalled: z14.boolean(),
-  duckdbVersion: z14.string().nullable().optional(),
-  duckdbSpec: z14.string(),
-  pluginDir: z14.string()
-});
-var backlinksInstallResultDtoSchema = z14.object({
-  installed: z14.boolean(),
-  version: z14.string(),
-  path: z14.string(),
-  alreadyPresent: z14.boolean()
-});
-var ccAvailableReleaseSchema = z14.object({
-  release: z14.string(),
-  vertexUrl: z14.string(),
-  edgesUrl: z14.string(),
-  vertexBytes: z14.number().int().nullable(),
-  edgesBytes: z14.number().int().nullable(),
-  lastModified: z14.string().nullable()
-});
-var ccCachedReleaseSchema = z14.object({
-  release: z14.string(),
-  syncStatus: ccReleaseSyncStatusSchema.nullable(),
-  bytes: z14.number().int(),
-  lastUsedAt: z14.string().nullable()
-});
-
-// ../contracts/src/composites.ts
-import { z as z15 } from "zod";
-var searchHitKindSchema = z15.enum(["snapshot", "insight"]);
-var projectSearchSnapshotHitSchema = z15.object({
-  kind: z15.literal("snapshot"),
-  id: z15.string(),
-  runId: z15.string(),
-  keyword: z15.string(),
-  provider: z15.string(),
-  model: z15.string().nullable(),
-  citationState: citationStateSchema,
-  matchedField: z15.enum(["answerText", "citedDomains", "searchQueries", "keyword"]),
-  snippet: z15.string(),
-  createdAt: z15.string()
-});
-var projectSearchInsightHitSchema = z15.object({
-  kind: z15.literal("insight"),
-  id: z15.string(),
-  runId: z15.string().nullable(),
-  type: z15.enum(["regression", "gain", "opportunity"]),
-  severity: z15.enum(["critical", "high", "medium", "low"]),
-  title: z15.string(),
-  keyword: z15.string(),
-  provider: z15.string(),
-  matchedField: z15.enum(["title", "keyword", "recommendation", "cause"]),
-  snippet: z15.string(),
-  dismissed: z15.boolean(),
-  createdAt: z15.string()
-});
-var projectSearchHitSchema = z15.discriminatedUnion("kind", [
-  projectSearchSnapshotHitSchema,
-  projectSearchInsightHitSchema
-]);
-var projectSearchResponseSchema = z15.object({
-  query: z15.string(),
-  totalHits: z15.number().int().nonnegative(),
-  truncated: z15.boolean(),
-  hits: z15.array(projectSearchHitSchema)
-});
-
-// ../contracts/src/content.ts
-import { z as z16 } from "zod";
-var contentActionSchema = z16.enum(["create", "expand", "refresh", "add-schema"]);
-var ContentActions = contentActionSchema.enum;
-var demandSourceSchema = z16.enum(["gsc", "competitor-evidence", "both"]);
-var DemandSources = demandSourceSchema.enum;
-var actionConfidenceSchema = z16.enum(["high", "medium", "low"]);
-var ActionConfidences = actionConfidenceSchema.enum;
-var pageTypeSchema = z16.enum([
-  "blog-post",
-  "comparison",
-  "listicle",
-  "how-to",
-  "guide",
-  "glossary"
-]);
-var PageTypes = pageTypeSchema.enum;
-var contentActionStateSchema = z16.enum([
-  "proposed",
-  "briefed",
-  "payload-generated",
-  "draft-created",
-  "published",
-  "validated",
-  "dismissed"
-]);
-var ContentActionStates = contentActionStateSchema.enum;
-var ourBestPageSchema = z16.object({
-  url: z16.string(),
-  gscImpressions: z16.number().nonnegative(),
-  gscClicks: z16.number().nonnegative(),
-  // Null when the page came from the inventory fallback (no GSC ranking data).
-  gscAvgPosition: z16.number().nonnegative().nullable(),
-  organicSessions: z16.number().nonnegative()
-});
-var winningCompetitorSchema = z16.object({
-  domain: z16.string(),
-  url: z16.string(),
-  title: z16.string(),
-  citationCount: z16.number().int().nonnegative()
-});
-var scoreBreakdownSchema = z16.object({
-  demand: z16.number(),
-  competitor: z16.number(),
-  absence: z16.number(),
-  gapSeverity: z16.number()
-});
-var existingActionRefSchema = z16.object({
-  actionId: z16.string(),
-  state: contentActionStateSchema,
-  lastUpdated: z16.string()
-});
-var contentTargetRowDtoSchema = z16.object({
-  targetRef: z16.string(),
-  query: z16.string(),
-  action: contentActionSchema,
-  ourBestPage: ourBestPageSchema.nullable(),
-  winningCompetitor: winningCompetitorSchema.nullable(),
-  score: z16.number(),
-  scoreBreakdown: scoreBreakdownSchema,
-  drivers: z16.array(z16.string()),
-  demandSource: demandSourceSchema,
-  actionConfidence: actionConfidenceSchema,
-  existingAction: existingActionRefSchema.nullable()
-});
-var contentTargetsResponseDtoSchema = z16.object({
-  targets: z16.array(contentTargetRowDtoSchema),
-  contextMetrics: z16.object({
-    totalAiReferralSessions: z16.number().int().nonnegative(),
-    latestRunId: z16.string(),
-    runTimestamp: z16.string()
-  })
-});
-var contentGroundingSourceSchema = z16.object({
-  uri: z16.string(),
-  title: z16.string(),
-  domain: z16.string(),
-  isOurDomain: z16.boolean(),
-  isCompetitor: z16.boolean(),
-  citationCount: z16.number().int().nonnegative(),
-  providers: z16.array(providerNameSchema)
-});
-var contentSourceRowDtoSchema = z16.object({
-  query: z16.string(),
-  groundingSources: z16.array(contentGroundingSourceSchema)
-});
-var contentSourcesResponseDtoSchema = z16.object({
-  sources: z16.array(contentSourceRowDtoSchema),
-  latestRunId: z16.string()
-});
-var contentGapRowDtoSchema = z16.object({
-  query: z16.string(),
-  competitorDomains: z16.array(z16.string()),
-  competitorCount: z16.number().int().nonnegative(),
-  missRate: z16.number().min(0).max(1),
-  lastSeenInRunId: z16.string()
-});
-var contentGapsResponseDtoSchema = z16.object({
-  gaps: z16.array(contentGapRowDtoSchema),
-  latestRunId: z16.string()
-});
-
-// ../contracts/src/doctor.ts
-import { z as z17 } from "zod";
-var checkStatusSchema = z17.enum(["ok", "warn", "fail", "skipped"]);
-var CheckStatuses = checkStatusSchema.enum;
-var checkScopeSchema = z17.enum(["global", "project"]);
-var CheckScopes = checkScopeSchema.enum;
-var checkCategorySchema = z17.enum([
-  "auth",
-  "config",
-  "providers",
-  "integrations",
-  "database",
-  "schedules"
-]);
-var CheckCategories = checkCategorySchema.enum;
-var checkResultSchema = z17.object({
-  id: z17.string(),
-  category: checkCategorySchema,
-  scope: checkScopeSchema,
-  title: z17.string(),
-  status: checkStatusSchema,
-  code: z17.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
-  summary: z17.string(),
-  remediation: z17.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
-  details: z17.record(z17.string(), z17.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
-  durationMs: z17.number().int().nonnegative().describe("How long the check took to execute.")
-});
-var doctorReportSchema = z17.object({
-  scope: checkScopeSchema,
-  project: z17.string().nullable().describe('Project name when scope is "project", null otherwise.'),
-  generatedAt: z17.string().describe("ISO-8601 timestamp when this doctor run started."),
-  durationMs: z17.number().int().nonnegative(),
-  summary: z17.object({
-    total: z17.number().int().nonnegative(),
-    ok: z17.number().int().nonnegative(),
-    warn: z17.number().int().nonnegative(),
-    fail: z17.number().int().nonnegative(),
-    skipped: z17.number().int().nonnegative()
-  }),
-  checks: z17.array(checkResultSchema)
-});
-function summarizeCheckResults(results) {
-  const summary = { total: results.length, ok: 0, warn: 0, fail: 0, skipped: 0 };
-  for (const result of results) {
-    switch (result.status) {
-      case CheckStatuses.ok:
-        summary.ok += 1;
-        break;
-      case CheckStatuses.warn:
-        summary.warn += 1;
-        break;
-      case CheckStatuses.fail:
-        summary.fail += 1;
-        break;
-      case CheckStatuses.skipped:
-        summary.skipped += 1;
-        break;
-    }
-  }
-  return summary;
-}
-
-// ../contracts/src/url-normalize.ts
-var STRIP_KEYS = /* @__PURE__ */ new Set([
-  // Click identifiers
-  "fbclid",
-  "gclid",
-  "msclkid",
-  "ttclid",
-  "li_fat_id",
-  "igshid",
-  "yclid",
-  "dclid",
-  "gbraid",
-  "wbraid",
-  "bingid",
-  // Mailchimp
-  "mc_cid",
-  "mc_eid",
-  // Google Analytics linkers
-  "_ga",
-  "_gl",
-  // Google Tag Manager debug
-  "gtm_latency",
-  "gtm_debug",
-  // WordPress internal noise
-  "preview",
-  "preview_id",
-  "preview_nonce",
-  "_thumbnail_id",
-  // Common cache-busters/versioning
-  "v",
-  "ver",
-  "version"
-]);
-function shouldStrip(key) {
-  if (STRIP_KEYS.has(key)) return true;
-  if (key.startsWith("utm_")) return true;
-  return false;
-}
-function parseQuery(query) {
-  if (query === "") return [];
-  return query.split("&").map((pair) => {
-    const eq = pair.indexOf("=");
-    if (eq === -1) return { key: pair, value: null };
-    return { key: pair.slice(0, eq), value: pair.slice(eq + 1) };
-  });
-}
-function encodeQuery(pairs) {
-  return pairs.map((p) => p.value === null ? p.key : `${p.key}=${p.value}`).join("&");
-}
-function collapseRootIndex(path2) {
-  if (path2 === "/index.html" || path2 === "/index.php") return "/";
-  return path2;
-}
-function dropTrailingSlash(path2) {
-  if (path2.length > 1 && path2.endsWith("/")) {
-    return path2.replace(/\/+$/, "");
-  }
-  return path2;
-}
-function normalizeUrlPath(input) {
-  if (input == null) return null;
-  let trimmed = input.trim();
-  if (trimmed === "") return null;
-  trimmed = trimmed.replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
-  if (trimmed === "" || trimmed === "/") return "/";
-  if (trimmed === "(not set)") return null;
-  trimmed = trimmed.replace(/([a-zA-Z0-9])([).]+)$/, "$1");
-  if (trimmed.startsWith("/)") || trimmed.startsWith("/ ")) {
-    trimmed = "/";
-  }
-  if (trimmed.includes(" ")) {
-    trimmed = trimmed.split(" ")[0];
-  }
-  if (trimmed === "" || trimmed === "/") return "/";
-  let pathPart;
-  let queryPart;
-  if (/^https?:\/\//i.test(trimmed)) {
-    let url;
-    try {
-      url = new URL(trimmed);
-    } catch {
-      return null;
-    }
-    pathPart = url.pathname || "/";
-    queryPart = url.search.startsWith("?") ? url.search.slice(1) : url.search;
-  } else {
-    let raw = trimmed;
-    const hashIdx = raw.indexOf("#");
-    if (hashIdx !== -1) raw = raw.slice(0, hashIdx);
-    const qIdx = raw.indexOf("?");
-    if (qIdx === -1) {
-      pathPart = raw;
-      queryPart = "";
-    } else {
-      pathPart = raw.slice(0, qIdx);
-      queryPart = raw.slice(qIdx + 1);
-    }
-  }
-  if (pathPart === "") pathPart = "/";
-  pathPart = collapseRootIndex(pathPart);
-  pathPart = dropTrailingSlash(pathPart);
-  const pairs = parseQuery(queryPart).filter((p) => !shouldStrip(p.key));
-  pairs.sort((a, b) => {
-    if (a.key < b.key) return -1;
-    if (a.key > b.key) return 1;
-    return 0;
-  });
-  if (pairs.length === 0) return pathPart;
-  return `${pathPart}?${encodeQuery(pairs)}`;
-}
-
-// ../contracts/src/citations.ts
-import { z as z18 } from "zod";
-var citationCoverageProviderSchema = z18.object({
-  provider: z18.string(),
-  citationState: citationStateSchema,
-  cited: z18.boolean(),
-  mentioned: z18.boolean(),
-  runId: z18.string(),
-  runCreatedAt: z18.string()
-});
-var citationCoverageRowSchema = z18.object({
-  keywordId: z18.string(),
-  keyword: z18.string(),
-  providers: z18.array(citationCoverageProviderSchema),
-  citedCount: z18.number().int().nonnegative(),
-  mentionedCount: z18.number().int().nonnegative(),
-  totalProviders: z18.number().int().nonnegative()
-});
-var competitorGapRowSchema = z18.object({
-  keywordId: z18.string(),
-  keyword: z18.string(),
-  provider: z18.string(),
-  citingCompetitors: z18.array(z18.string()),
-  runId: z18.string(),
-  runCreatedAt: z18.string()
-});
-var citationVisibilitySummarySchema = z18.object({
-  providersConfigured: z18.number().int().nonnegative(),
-  providersCiting: z18.number().int().nonnegative(),
-  providersMentioning: z18.number().int().nonnegative(),
-  totalKeywords: z18.number().int().nonnegative(),
-  // Cross-tab buckets — each tracked keyword with at least one snapshot lands
-  // in exactly one of these. Keywords with zero snapshots are not counted in
-  // any bucket; (sum of buckets) ≤ totalKeywords.
-  keywordsCitedAndMentioned: z18.number().int().nonnegative(),
-  keywordsCitedOnly: z18.number().int().nonnegative(),
-  keywordsMentionedOnly: z18.number().int().nonnegative(),
-  keywordsInvisible: z18.number().int().nonnegative(),
-  latestRunId: z18.string().nullable(),
-  latestRunAt: z18.string().nullable()
-});
-var citationVisibilityResponseSchema = z18.object({
-  summary: citationVisibilitySummarySchema,
-  byKeyword: z18.array(citationCoverageRowSchema),
-  competitorGaps: z18.array(competitorGapRowSchema),
-  status: z18.enum(["ready", "no-data"]),
-  reason: z18.enum(["no-runs-yet", "no-keywords"]).optional()
-});
-function emptyCitationVisibility(reason) {
-  return {
-    summary: {
-      providersConfigured: 0,
-      providersCiting: 0,
-      providersMentioning: 0,
-      totalKeywords: 0,
-      keywordsCitedAndMentioned: 0,
-      keywordsCitedOnly: 0,
-      keywordsMentionedOnly: 0,
-      keywordsInvisible: 0,
-      latestRunId: null,
-      latestRunAt: null
-    },
-    byKeyword: [],
-    competitorGaps: [],
-    status: "no-data",
-    reason
-  };
-}
-function citationStateToCited(state) {
-  return state === "cited";
-}
-
-// ../contracts/src/skills.ts
-import { z as z19 } from "zod";
-var codingAgentSchema = z19.enum(["claude", "codex"]);
-var CodingAgents = codingAgentSchema.enum;
-var skillsClientSchema = z19.enum(["claude", "codex", "all"]);
-var SkillsClients = skillsClientSchema.enum;
-
 // src/client.ts
 function createApiClient() {
   const config = loadConfig();
@@ -2745,21 +922,21 @@ var ApiClient = class {
 };
 
 // src/mcp/tool-registry.ts
-import { z as z21 } from "zod";
+import { z as z2 } from "zod";
 
 // src/mcp/schema.ts
-import { z as z20 } from "zod";
-var projectNameSchema = z20.string().min(1).describe("Canonry project name.");
-var runIdSchema = z20.string().min(1).describe("Canonry run ID.");
-var insightIdSchema = z20.string().min(1).describe("Canonry insight ID.");
-var analyticsWindowSchema = z20.enum(["7d", "30d", "90d", "all"]).describe("Analytics time window.");
-var emptyInputSchema = z20.object({});
-var projectInputSchema = z20.object({
+import { z } from "zod";
+var projectNameSchema = z.string().min(1).describe("Canonry project name.");
+var runIdSchema = z.string().min(1).describe("Canonry run ID.");
+var insightIdSchema = z.string().min(1).describe("Canonry insight ID.");
+var analyticsWindowSchema = z.enum(["7d", "30d", "90d", "all"]).describe("Analytics time window.");
+var emptyInputSchema = z.object({});
+var projectInputSchema = z.object({
   project: projectNameSchema
 });
 function toJsonSchema(schema, name) {
   return {
-    ...z20.toJSONSchema(schema, { target: "draft-7" }),
+    ...z.toJSONSchema(schema, { target: "draft-7" }),
     title: name
   };
 }
@@ -2801,119 +978,119 @@ function defineTool(tool) {
     inputJsonSchema: toJsonSchema(tool.inputSchema, tool.name)
   };
 }
-var runTriggerInputSchema = z21.object({
+var runTriggerInputSchema = z2.object({
   project: projectNameSchema,
   request: runTriggerRequestSchema.optional()
 });
-var runsListInputSchema = z21.object({
+var runsListInputSchema = z2.object({
   project: projectNameSchema,
-  limit: z21.number().int().positive().max(500).optional()
+  limit: z2.number().int().positive().max(500).optional()
 });
-var runGetInputSchema = z21.object({
+var runGetInputSchema = z2.object({
   runId: runIdSchema
 });
-var timelineInputSchema = z21.object({
+var timelineInputSchema = z2.object({
   project: projectNameSchema,
-  location: z21.string().optional().describe("Location label. Use an empty string for locationless results.")
+  location: z2.string().optional().describe("Location label. Use an empty string for locationless results.")
 });
-var snapshotsListInputSchema = z21.object({
+var snapshotsListInputSchema = z2.object({
   project: projectNameSchema,
-  limit: z21.number().int().positive().max(500).optional(),
-  offset: z21.number().int().nonnegative().optional(),
-  location: z21.string().optional().describe("Location label. Use an empty string for locationless results.")
+  limit: z2.number().int().positive().max(500).optional(),
+  offset: z2.number().int().nonnegative().optional(),
+  location: z2.string().optional().describe("Location label. Use an empty string for locationless results.")
 });
-var snapshotsDiffInputSchema = z21.object({
+var snapshotsDiffInputSchema = z2.object({
   project: projectNameSchema,
   run1: runIdSchema,
   run2: runIdSchema
 });
-var insightsListInputSchema = z21.object({
+var insightsListInputSchema = z2.object({
   project: projectNameSchema,
-  dismissed: z21.boolean().optional(),
+  dismissed: z2.boolean().optional(),
   runId: runIdSchema.optional()
 });
-var insightInputSchema = z21.object({
+var insightInputSchema = z2.object({
   project: projectNameSchema,
   insightId: insightIdSchema
 });
-var healthHistoryInputSchema = z21.object({
+var healthHistoryInputSchema = z2.object({
   project: projectNameSchema,
-  limit: z21.number().int().positive().max(100).optional()
+  limit: z2.number().int().positive().max(100).optional()
 });
-var gscPerformanceInputSchema = z21.object({
+var gscPerformanceInputSchema = z2.object({
   project: projectNameSchema,
-  startDate: z21.string().optional(),
-  endDate: z21.string().optional(),
-  query: z21.string().optional(),
-  page: z21.string().optional(),
-  limit: z21.number().int().positive().max(500).optional(),
+  startDate: z2.string().optional(),
+  endDate: z2.string().optional(),
+  query: z2.string().optional(),
+  page: z2.string().optional(),
+  limit: z2.number().int().positive().max(500).optional(),
   window: analyticsWindowSchema.optional()
 });
-var gscInspectionsInputSchema = z21.object({
+var gscInspectionsInputSchema = z2.object({
   project: projectNameSchema,
-  url: z21.string().optional(),
-  limit: z21.number().int().positive().max(500).optional()
+  url: z2.string().optional(),
+  limit: z2.number().int().positive().max(500).optional()
 });
-var gscCoverageHistoryInputSchema = z21.object({
+var gscCoverageHistoryInputSchema = z2.object({
   project: projectNameSchema,
-  limit: z21.number().int().positive().max(500).optional()
+  limit: z2.number().int().positive().max(500).optional()
 });
-var gaWindowInputSchema = z21.object({
+var gaWindowInputSchema = z2.object({
   project: projectNameSchema,
   window: analyticsWindowSchema.optional()
 });
 var gaTrafficInputSchema = gaWindowInputSchema.extend({
-  limit: z21.number().int().positive().max(500).optional()
+  limit: z2.number().int().positive().max(500).optional()
 });
-var keywordsInputSchema = z21.object({
+var keywordsInputSchema = z2.object({
   project: projectNameSchema,
   request: keywordBatchRequestSchema
 });
-var keywordGenerateInputSchema = z21.object({
+var keywordGenerateInputSchema = z2.object({
   project: projectNameSchema,
   request: keywordGenerateRequestSchema
 });
-var competitorsInputSchema = z21.object({
+var competitorsInputSchema = z2.object({
   project: projectNameSchema,
   request: competitorBatchRequestSchema
 });
-var projectUpsertInputSchema = z21.object({
+var projectUpsertInputSchema = z2.object({
   project: projectNameSchema,
   request: projectUpsertRequestSchema
 });
-var applyConfigInputSchema = z21.object({
+var applyConfigInputSchema = z2.object({
   config: projectConfigSchema
 });
-var scheduleSetInputSchema = z21.object({
+var scheduleSetInputSchema = z2.object({
   project: projectNameSchema,
   schedule: scheduleUpsertRequestSchema
 });
-var agentWebhookAttachInputSchema = z21.object({
+var agentWebhookAttachInputSchema = z2.object({
   project: projectNameSchema,
-  url: z21.string().url()
+  url: z2.string().url()
 });
-var doctorInputSchema = z21.object({
+var doctorInputSchema = z2.object({
   project: projectNameSchema.optional().describe("Project name to scope project-level checks. Omit to run global checks (provider keys, config, etc.)."),
-  checks: z21.array(z21.string().min(1)).optional().describe('Optional check IDs or wildcard prefixes (e.g. "google.auth.*", "config.providers"). Empty/omitted runs all matching checks for the chosen scope.')
+  checks: z2.array(z2.string().min(1)).optional().describe('Optional check IDs or wildcard prefixes (e.g. "google.auth.*", "config.providers"). Empty/omitted runs all matching checks for the chosen scope.')
 });
-var contentTargetsInputSchema = z21.object({
+var contentTargetsInputSchema = z2.object({
   project: projectNameSchema,
-  limit: z21.number().int().positive().max(500).optional().describe("Max rows. Defaults to all. Use a small number (3-10) when summarizing for the user."),
-  includeInProgress: z21.boolean().optional().describe("Include rows that already have an in-flight tracked action. Default false.")
+  limit: z2.number().int().positive().max(500).optional().describe("Max rows. Defaults to all. Use a small number (3-10) when summarizing for the user."),
+  includeInProgress: z2.boolean().optional().describe("Include rows that already have an in-flight tracked action. Default false.")
 });
-var backlinksDomainsInputSchema = z21.object({
+var backlinksDomainsInputSchema = z2.object({
   project: projectNameSchema,
-  limit: z21.number().int().positive().max(200).optional().describe("Max linking-domain rows. Default 50, max 200."),
-  release: z21.string().optional().describe("Common Crawl release id (e.g., cc-main-2026-jan-feb-mar). Omit for the most recent release with data.")
+  limit: z2.number().int().positive().max(200).optional().describe("Max linking-domain rows. Default 50, max 200."),
+  release: z2.string().optional().describe("Common Crawl release id (e.g., cc-main-2026-jan-feb-mar). Omit for the most recent release with data.")
 });
-var memoryUpsertInputSchema = z21.object({
+var memoryUpsertInputSchema = z2.object({
   project: projectNameSchema,
-  key: z21.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH).describe(`Stable identifier for the note (max ${AGENT_MEMORY_KEY_MAX_LENGTH} chars). Writing the same key overwrites the prior value.`),
-  value: z21.string().min(1).describe(`Plain-text note body (max ${AGENT_MEMORY_VALUE_MAX_BYTES} bytes). Use for durable operator preferences, migration context, or non-obvious reasoning that should survive future sessions.`)
+  key: z2.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH).describe(`Stable identifier for the note (max ${AGENT_MEMORY_KEY_MAX_LENGTH} chars). Writing the same key overwrites the prior value.`),
+  value: z2.string().min(1).describe(`Plain-text note body (max ${AGENT_MEMORY_VALUE_MAX_BYTES} bytes). Use for durable operator preferences, migration context, or non-obvious reasoning that should survive future sessions.`)
 });
-var memoryForgetInputSchema = z21.object({
+var memoryForgetInputSchema = z2.object({
   project: projectNameSchema,
-  key: z21.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH).describe("Exact key of the note to remove. No-op (status=missing) when no note exists for that key.")
+  key: z2.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH).describe("Exact key of the note to remove. No-op (status=missing) when no note exists for that key.")
 });
 var AGENT_WEBHOOK_EVENTS = [
   notificationEventSchema.enum["run.completed"],
@@ -2972,10 +1149,10 @@ var canonryMcpTools = [
     description: "Search query snapshots and intelligence insights for the given text. Looks at snapshot answer text, cited domains, raw provider responses, and insight title/keyword/recommendation/cause. Returns ranked hits with snippets \u2014 use it instead of paginating snapshots when you need to find a competitor mention or term.",
     access: "read",
     tier: "core",
-    inputSchema: z21.object({
+    inputSchema: z2.object({
       project: projectNameSchema,
-      q: z21.string().min(2).describe("Search term, at least 2 characters."),
-      limit: z21.number().int().positive().max(50).optional().describe("Max combined hits (1-50, default 25).")
+      q: z2.string().min(2).describe("Search term, at least 2 characters."),
+      limit: z2.number().int().positive().max(50).optional().describe("Max combined hits (1-50, default 25).")
     }),
     annotations: readAnnotations(),
     openApiOperations: ["GET /api/v1/projects/{name}/search"],
@@ -3674,74 +1851,6 @@ export {
   usageError,
   isEndpointMissing,
   printCliError,
-  providerQuotaPolicySchema,
-  ProviderNames,
-  isBrowserProvider,
-  resolveProviderInput,
-  locationContextSchema,
-  notificationEventSchema,
-  findDuplicateLocationLabels,
-  hasLocationLabel,
-  projectUpsertRequestSchema,
-  keywordGenerateRequestSchema,
-  competitorBatchRequestSchema,
-  normalizeProjectDomain,
-  registrableDomain,
-  brandLabelFromDomain,
-  effectiveDomains,
-  projectConfigSchema,
-  AppError,
-  notFound,
-  validationError,
-  authRequired,
-  authInvalid,
-  providerError,
-  runInProgress,
-  runNotCancellable,
-  unsupportedKind,
-  notImplemented,
-  deliveryFailed,
-  agentBusy,
-  missingDependency,
-  internalError,
-  wordpressEnvSchema,
-  AgentProviderIds,
-  AGENT_PROVIDER_IDS,
-  isAgentProviderId,
-  RunStatuses,
-  RunKinds,
-  RunTriggers,
-  CitationStates,
-  runTriggerRequestSchema,
-  parseRunError,
-  buildRunErrorFromMessages,
-  serializeRunError,
-  formatRunErrorOneLine,
-  snapshotRequestSchema,
-  scheduleUpsertRequestSchema,
-  parseWindow,
-  windowCutoff,
-  categorizeSource,
-  categoryLabel,
-  extractAnswerMentions,
-  determineAnswerMentioned,
-  visibilityStateFromAnswerMentioned,
-  brandKeyFromText,
-  MemorySources,
-  AGENT_MEMORY_VALUE_MAX_BYTES,
-  agentMemoryUpsertRequestSchema,
-  agentMemoryDeleteRequestSchema,
-  CcReleaseSyncStatuses,
-  CheckStatuses,
-  CheckScopes,
-  CheckCategories,
-  summarizeCheckResults,
-  normalizeUrlPath,
-  emptyCitationVisibility,
-  citationStateToCited,
-  CodingAgents,
-  skillsClientSchema,
-  SkillsClients,
   createApiClient,
   ApiClient,
   canonryMcpTools