@ainyc/canonry 2.5.1 → 2.8.2

package/dist/chunk-FPZUQADO.js

@@ -0,0 +1,2152 @@
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parse, stringify } from "yaml";
+function normalizeGoogleConfig(config) {
+  if (!config.google) return;
+  config.google.connections = (config.google.connections ?? []).map((connection) => ({
+    ...connection,
+    propertyId: connection.propertyId ?? null,
+    refreshToken: connection.refreshToken ?? null,
+    tokenExpiresAt: connection.tokenExpiresAt ?? null,
+    scopes: connection.scopes ?? []
+  }));
+}
+function normalizeWordpressConfig(config) {
+  if (!config.wordpress) return;
+  config.wordpress.connections = (config.wordpress.connections ?? []).map((connection) => ({
+    ...connection,
+    url: connection.url.replace(/\/$/, ""),
+    stagingUrl: connection.stagingUrl?.replace(/\/$/, ""),
+    defaultEnv: connection.defaultEnv ?? "live"
+  }));
+}
+function getConfigDir() {
+  const override = process.env.CANONRY_CONFIG_DIR?.trim();
+  if (override) {
+    return override;
+  }
+  return path.join(os.homedir(), ".canonry");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.yaml");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) {
+    throw new Error(
+      `Config not found at ${configPath}.
+Run "canonry init" to set up interactively, or "canonry init --gemini-key <key>" for non-interactive setup.
+For CI/Docker, use "canonry bootstrap" with env vars (GEMINI_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, PERPLEXITY_API_KEY, GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET).`
+    );
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  const parsed = parse(raw);
+  if (!parsed.apiUrl || !parsed.database || !parsed.apiKey) {
+    const missing = [
+      !parsed.apiUrl && "apiUrl",
+      !parsed.database && "database",
+      !parsed.apiKey && "apiKey"
+    ].filter(Boolean).join(", ");
+    throw new Error(
+      `Invalid config at ${configPath} \u2014 missing: ${missing}.
+These fields are auto-generated. Run "canonry init" (or "canonry init --gemini-key <key>" for non-interactive setup) to create a valid config.
+Do not write config.yaml by hand; use "canonry init", "canonry settings", or "canonry bootstrap" instead.`
+    );
+  }
+  if (parsed.geminiApiKey && !parsed.providers?.gemini) {
+    parsed.providers = {
+      ...parsed.providers,
+      gemini: {
+        apiKey: parsed.geminiApiKey,
+        model: parsed.geminiModel,
+        quota: parsed.geminiQuota
+      }
+    };
+  }
+  normalizeGoogleConfig(parsed);
+  normalizeWordpressConfig(parsed);
+  const portOverride = process.env.CANONRY_PORT?.trim();
+  if (portOverride) {
+    try {
+      const url = new URL(parsed.apiUrl);
+      url.port = portOverride;
+      parsed.apiUrl = url.origin;
+    } catch {
+    }
+  }
+  if ("CANONRY_BASE_PATH" in process.env) {
+    const val = process.env.CANONRY_BASE_PATH.trim();
+    parsed.basePath = val || void 0;
+  }
+  if (parsed.basePath) {
+    const normalizedBase = "/" + parsed.basePath.replace(/^\/|\/$/g, "");
+    try {
+      const url = new URL(parsed.apiUrl);
+      if (normalizedBase !== "/" && !url.pathname.startsWith(normalizedBase)) {
+        parsed.apiUrl = url.origin + normalizedBase;
+      }
+    } catch {
+    }
+  }
+  return parsed;
+}
+function loadConfigRaw() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return parse(fs.readFileSync(configPath, "utf-8")) ?? null;
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  const configPath = getConfigPath();
+  const onDisk = loadConfigRaw();
+  const merged = onDisk ? { ...onDisk } : {};
+  for (const [key, value] of Object.entries(config)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  if (onDisk) {
+    if (process.env.CANONRY_PORT?.trim() || onDisk.basePath) {
+      merged.apiUrl = onDisk.apiUrl;
+    }
+    if ("CANONRY_BASE_PATH" in process.env) {
+      if (onDisk.basePath !== void 0) {
+        merged.basePath = onDisk.basePath;
+      } else {
+        delete merged.basePath;
+      }
+    }
+  }
+  const yaml = stringify(merged);
+  fs.writeFileSync(configPath, yaml, { encoding: "utf-8", mode: 384 });
+}
+function saveConfigPatch(patch) {
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  const configPath = getConfigPath();
+  let base = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      base = parse(raw) ?? {};
+    } catch {
+      base = {};
+    }
+  }
+  const merged = { ...base, ...patch };
+  if (base.database) merged.database = base.database;
+  if (base.apiKey) merged.apiKey = base.apiKey;
+  if (base.anonymousId) merged.anonymousId = base.anonymousId;
+  if (base.dashboardPasswordHash) merged.dashboardPasswordHash = base.dashboardPasswordHash;
+  if (base.providers && patch.providers) {
+    merged.providers = { ...base.providers };
+    for (const [key, patchEntry] of Object.entries(patch.providers)) {
+      const baseEntry = base.providers[key] ?? {};
+      merged.providers[key] = { ...baseEntry, ...patchEntry };
+    }
+  }
+  const yaml = stringify(merged);
+  fs.writeFileSync(configPath, yaml, { encoding: "utf-8", mode: 384 });
+}
+function configExists() {
+  return fs.existsSync(getConfigPath());
+}
+
+// src/cli-error.ts
+var EXIT_USER_ERROR = 1;
+var EXIT_SYSTEM_ERROR = 2;
+var CliError = class extends Error {
+  code;
+  displayMessage;
+  details;
+  exitCode;
+  constructor(options) {
+    super(options.message);
+    this.name = "CliError";
+    this.code = options.code;
+    this.displayMessage = options.displayMessage;
+    this.details = options.details;
+    this.exitCode = options.exitCode ?? EXIT_USER_ERROR;
+  }
+};
+function usageError(displayMessage, options) {
+  const firstLine = displayMessage.split("\n", 1)[0] ?? "Error: invalid command usage";
+  return new CliError({
+    code: "CLI_USAGE_ERROR",
+    message: options?.message ?? firstLine.replace(/^Error:\s*/, ""),
+    displayMessage,
+    details: options?.details
+  });
+}
+function isEndpointMissing(err) {
+  if (!(err instanceof CliError)) return false;
+  const status = err.details?.httpStatus;
+  return status === 404 || status === 405;
+}
+function printCliError(err, format) {
+  if (format === "json") {
+    if (err instanceof CliError) {
+      console.error(
+        JSON.stringify(
+          {
+            error: {
+              code: err.code,
+              message: err.message,
+              ...err.details ? { details: err.details } : {}
+            }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const message = err instanceof Error ? err.message : "An unexpected error occurred";
+    console.error(
+      JSON.stringify(
+        {
+          error: {
+            code: "CLI_ERROR",
+            message
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (err instanceof CliError && err.displayMessage) {
+    console.error(err.displayMessage);
+    return;
+  }
+  if (err instanceof Error) {
+    console.error(`Error: ${err.message}`);
+    return;
+  }
+  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 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: z2.string().nullable().optional(),
+  createdAt: z2.string()
+});
+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\./, "");
+}
+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(["answer", "citation"]);
+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 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(),
+  totalUsers: z12.number(),
+  topPages: z12.array(z12.object({
+    landingPage: z12.string(),
+    sessions: z12.number(),
+    organicSessions: z12.number(),
+    users: z12.number()
+  })),
+  aiReferrals: z12.array(ga4AiReferralDtoSchema),
+  /** Deduped AI session total: MAX(sessions) per date+source+medium across attribution dimensions, then summed. */
+  aiSessionsDeduped: z12.number(),
+  /** Deduped AI user total: MAX(users) per date+source+medium across attribution dimensions, then summed. */
+  aiUsersDeduped: 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). */
+  aiSharePct: z12.number(),
+  /** Social sessions as a percentage of total sessions (0–100, rounded). */
+  socialSharePct: z12.number(),
+  lastSyncedAt: z12.string().nullable()
+});
+var ga4AiReferralHistoryEntrySchema = z12.object({
+  date: z12.string(),
+  source: z12.string(),
+  medium: 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"
+]);
+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 normalizedDisplayName = normalizeText(displayName);
+  if (normalizedDisplayName && normalizeText(answerText).includes(normalizedDisplayName)) {
+    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 hostname = normalizeProjectDomain(domain).split("/")[0] ?? "";
+    for (const label of hostname.split(".").filter(Boolean)) {
+      const token = label.replace(/[^a-z0-9]/gi, "").toLowerCase();
+      if (isDistinctiveToken(token)) tokens.add(token);
+    }
+  }
+  return [...tokens];
+}
+function extractDistinctiveTokens(value) {
+  return normalizeText(value).split(" ").filter(isDistinctiveToken);
+}
+function isDistinctiveToken(token) {
+  if (token.length < 4) return false;
+  return !GENERIC_TOKENS.has(token);
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ../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()
+});
+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()
+});
+
+// src/client.ts
+function createApiClient() {
+  const config = loadConfig();
+  const basePathResolved = !!config.basePath || "CANONRY_BASE_PATH" in process.env;
+  return new ApiClient(config.apiUrl, config.apiKey, { skipProbe: basePathResolved });
+}
+var ApiClient = class {
+  baseUrl;
+  originUrl;
+  apiKey;
+  probePromise = null;
+  probeSkipped;
+  constructor(baseUrl, apiKey, opts) {
+    this.originUrl = baseUrl.replace(/\/$/, "");
+    this.baseUrl = this.originUrl + "/api/v1";
+    this.apiKey = apiKey;
+    this.probeSkipped = opts?.skipProbe ?? false;
+  }
+  /**
+   * On first API call, probe /health to auto-discover basePath when the user
+   * hasn't configured one locally. This lets `canonry run` in a separate shell
+   * discover that the server is running at e.g. /canonry/ without requiring
+   * config.yaml edits or CANONRY_BASE_PATH in every shell.
+   */
+  probeBasePath() {
+    if (this.probeSkipped) return Promise.resolve();
+    if (!this.probePromise) {
+      this.probePromise = (async () => {
+        try {
+          const origin = new URL(this.originUrl).origin;
+          const res = await fetch(`${origin}/health`, {
+            signal: AbortSignal.timeout(2e3)
+          });
+          if (res.ok) {
+            const body = await res.json();
+            if (body.basePath && typeof body.basePath === "string") {
+              const normalized = "/" + body.basePath.replace(/^\/|\/$/g, "");
+              if (normalized !== "/") {
+                this.originUrl = origin + normalized;
+                this.baseUrl = this.originUrl + "/api/v1";
+              }
+            }
+          }
+        } catch {
+        }
+      })();
+    }
+    return this.probePromise;
+  }
+  async request(method, path2, body) {
+    await this.probeBasePath();
+    const url = `${this.baseUrl}${path2}`;
+    const serializedBody = body != null ? JSON.stringify(body) : void 0;
+    const headers = {
+      "Authorization": `Bearer ${this.apiKey}`,
+      "Accept": "application/json",
+      ...serializedBody != null ? { "Content-Type": "application/json" } : {}
+    };
+    let res;
+    try {
+      res = await fetch(url, {
+        method,
+        headers,
+        body: serializedBody
+      });
+    } catch (err) {
+      if (err instanceof CliError) throw err;
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("fetch failed") || msg.includes("ECONNREFUSED") || msg.includes("connect ECONNREFUSED")) {
+        throw new CliError({
+          code: "CONNECTION_ERROR",
+          message: `Could not connect to canonry server at ${this.baseUrl.replace("/api/v1", "")}. Start it with "canonry serve" (or "canonry serve &" to run in background).`,
+          exitCode: EXIT_SYSTEM_ERROR
+        });
+      }
+      throw new CliError({ code: "CONNECTION_ERROR", message: msg, exitCode: EXIT_SYSTEM_ERROR });
+    }
+    if (!res.ok) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = { error: { code: "UNKNOWN", message: res.statusText } };
+      }
+      const errorObj = errorBody && typeof errorBody === "object" && "error" in errorBody && errorBody.error && typeof errorBody.error === "object" ? errorBody.error : null;
+      const msg = errorObj?.message ? String(errorObj.message) : `HTTP ${res.status}: ${res.statusText}`;
+      const code = errorObj?.code ? String(errorObj.code) : "API_ERROR";
+      const exitCode = res.status >= 500 ? EXIT_SYSTEM_ERROR : EXIT_USER_ERROR;
+      throw new CliError({
+        code,
+        message: msg,
+        exitCode,
+        details: {
+          ...errorObj?.details ?? {},
+          httpStatus: res.status
+        }
+      });
+    }
+    if (res.status === 204) {
+      return void 0;
+    }
+    return await res.json();
+  }
+  async getAgentTranscript(project) {
+    return this.request(
+      "GET",
+      `/projects/${encodeURIComponent(project)}/agent/transcript`
+    );
+  }
+  async resetAgentTranscript(project) {
+    await this.request(
+      "DELETE",
+      `/projects/${encodeURIComponent(project)}/agent/transcript`
+    );
+  }
+  async listAgentProviders(project) {
+    return this.request(
+      "GET",
+      `/projects/${encodeURIComponent(project)}/agent/providers`
+    );
+  }
+  async listAgentMemory(project) {
+    return this.request(
+      "GET",
+      `/projects/${encodeURIComponent(project)}/agent/memory`
+    );
+  }
+  async setAgentMemory(project, body) {
+    return this.request(
+      "PUT",
+      `/projects/${encodeURIComponent(project)}/agent/memory`,
+      body
+    );
+  }
+  async forgetAgentMemory(project, key) {
+    return this.request(
+      "DELETE",
+      `/projects/${encodeURIComponent(project)}/agent/memory`,
+      { key }
+    );
+  }
+  /**
+   * POST a request whose response body the caller intends to consume as a
+   * stream (e.g. the Aero agent SSE endpoint). Shares the probe + auth +
+   * structured-error behavior of `request()`; the caller reads `res.body`
+   * and releases the response when done.
+   */
+  async streamPost(path2, body, signal) {
+    await this.probeBasePath();
+    const url = `${this.baseUrl}${path2}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "text/event-stream"
+    };
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body ?? {}),
+        signal
+      });
+    } catch (err) {
+      if (err instanceof CliError) throw err;
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("fetch failed") || msg.includes("ECONNREFUSED") || msg.includes("connect ECONNREFUSED")) {
+        throw new CliError({
+          code: "CONNECTION_ERROR",
+          message: `Could not connect to canonry server at ${this.baseUrl.replace("/api/v1", "")}. Start it with "canonry serve" (or "canonry serve &" to run in background).`,
+          exitCode: EXIT_SYSTEM_ERROR
+        });
+      }
+      throw new CliError({ code: "CONNECTION_ERROR", message: msg, exitCode: EXIT_SYSTEM_ERROR });
+    }
+    if (!res.ok || !res.body) {
+      let errorBody;
+      try {
+        errorBody = await res.json();
+      } catch {
+        errorBody = { error: { code: "UNKNOWN", message: res.statusText } };
+      }
+      const errorObj = errorBody && typeof errorBody === "object" && "error" in errorBody && errorBody.error ? errorBody.error : null;
+      const msg = errorObj?.message ? String(errorObj.message) : `HTTP ${res.status}: ${res.statusText}`;
+      const code = errorObj?.code ? String(errorObj.code) : "API_ERROR";
+      const exitCode = res.status >= 500 ? EXIT_SYSTEM_ERROR : EXIT_USER_ERROR;
+      throw new CliError({ code, message: msg, exitCode, details: { httpStatus: res.status } });
+    }
+    return res;
+  }
+  async putProject(name, body) {
+    return this.request("PUT", `/projects/${encodeURIComponent(name)}`, body);
+  }
+  async listProjects() {
+    return this.request("GET", "/projects");
+  }
+  async getProject(name) {
+    return this.request("GET", `/projects/${encodeURIComponent(name)}`);
+  }
+  async deleteProject(name) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(name)}`);
+  }
+  async putKeywords(project, keywords) {
+    await this.request("PUT", `/projects/${encodeURIComponent(project)}/keywords`, { keywords });
+  }
+  async listKeywords(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/keywords`);
+  }
+  async deleteKeywords(project, keywords) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/keywords`, { keywords });
+  }
+  async appendKeywords(project, keywords) {
+    await this.request("POST", `/projects/${encodeURIComponent(project)}/keywords`, { keywords });
+  }
+  async listCompetitors(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/competitors`);
+  }
+  async appendCompetitors(project, competitors) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/competitors`, { competitors });
+  }
+  async deleteCompetitors(project, competitors) {
+    return this.request("DELETE", `/projects/${encodeURIComponent(project)}/competitors`, { competitors });
+  }
+  async triggerRun(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/runs`, body ?? {});
+  }
+  async listRuns(project, limit) {
+    const query = limit != null ? `?limit=${encodeURIComponent(String(limit))}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/runs${query}`);
+  }
+  async getLatestRun(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/runs/latest`);
+  }
+  async getRun(id) {
+    return this.request("GET", `/runs/${encodeURIComponent(id)}`);
+  }
+  async cancelRun(id) {
+    return this.request("POST", `/runs/${encodeURIComponent(id)}/cancel`);
+  }
+  async getTimeline(project, location) {
+    const qs = location != null ? `?location=${encodeURIComponent(location)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/timeline${qs}`);
+  }
+  async getHistory(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/history`);
+  }
+  async getSnapshots(project, opts) {
+    const params = new URLSearchParams();
+    if (opts?.limit != null) params.set("limit", String(opts.limit));
+    if (opts?.offset != null) params.set("offset", String(opts.offset));
+    if (opts?.location != null) params.set("location", opts.location);
+    const qs = params.toString();
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/snapshots${qs ? `?${qs}` : ""}`);
+  }
+  async getSnapshotDiff(project, run1, run2) {
+    const params = new URLSearchParams({ run1, run2 });
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/snapshots/diff?${params.toString()}`);
+  }
+  async getExport(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/export`);
+  }
+  async apply(config) {
+    return this.request("POST", "/apply", config);
+  }
+  async getStatus(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}`);
+  }
+  async getSettings() {
+    return this.request("GET", "/settings");
+  }
+  async createSnapshot(body) {
+    return this.request("POST", "/snapshot", body);
+  }
+  async updateProvider(name, body) {
+    return this.request("PUT", `/settings/providers/${encodeURIComponent(name)}`, body);
+  }
+  async putSchedule(project, body) {
+    return this.request("PUT", `/projects/${encodeURIComponent(project)}/schedule`, body);
+  }
+  async getSchedule(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/schedule`);
+  }
+  async deleteSchedule(project) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/schedule`);
+  }
+  async createNotification(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/notifications`, body);
+  }
+  async listNotifications(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/notifications`);
+  }
+  async deleteNotification(project, id) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/notifications/${encodeURIComponent(id)}`);
+  }
+  async testNotification(project, id) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/notifications/${encodeURIComponent(id)}/test`);
+  }
+  async addLocation(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/locations`, body);
+  }
+  async listLocations(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/locations`);
+  }
+  async removeLocation(project, label) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/locations/${encodeURIComponent(label)}`);
+  }
+  async setDefaultLocation(project, label) {
+    return this.request("PUT", `/projects/${encodeURIComponent(project)}/locations/default`, { label });
+  }
+  async getTelemetry() {
+    return this.request("GET", "/telemetry");
+  }
+  async updateTelemetry(enabled) {
+    return this.request("PUT", "/telemetry", { enabled });
+  }
+  async generateKeywords(project, provider, count) {
+    return this.request(
+      "POST",
+      `/projects/${encodeURIComponent(project)}/keywords/generate`,
+      { provider, count }
+    );
+  }
+  // Google connection management
+  async googleConnect(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/connect`, body);
+  }
+  async googleConnections(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/connections`);
+  }
+  async googleDisconnect(project, type) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/google/connections/${encodeURIComponent(type)}`);
+  }
+  async googleProperties(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/properties`);
+  }
+  async googleSetProperty(project, type, propertyId) {
+    return this.request("PUT", `/projects/${encodeURIComponent(project)}/google/connections/${encodeURIComponent(type)}/property`, { propertyId });
+  }
+  async googleSetSitemap(project, type, sitemapUrl) {
+    return this.request("PUT", `/projects/${encodeURIComponent(project)}/google/connections/${encodeURIComponent(type)}/sitemap`, { sitemapUrl });
+  }
+  // GSC data
+  async gscSync(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/gsc/sync`, body ?? {});
+  }
+  async gscPerformance(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/performance${qs}`);
+  }
+  async gscInspect(project, url) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/gsc/inspect`, { url });
+  }
+  async gscInspections(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/inspections${qs}`);
+  }
+  async gscDeindexed(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/deindexed`);
+  }
+  async gscCoverage(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/coverage`);
+  }
+  async gscCoverageHistory(project, params) {
+    const qs = params?.limit != null ? `?limit=${params.limit}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/coverage/history${qs}`);
+  }
+  async gscInspectSitemap(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/gsc/inspect-sitemap`, body ?? {});
+  }
+  async gscSitemaps(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/google/gsc/sitemaps`);
+  }
+  async gscDiscoverSitemaps(project) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/gsc/discover-sitemaps`, {});
+  }
+  // Analytics
+  async getAnalyticsMetrics(project, window) {
+    const qs = window ? `?window=${encodeURIComponent(window)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/analytics/metrics${qs}`);
+  }
+  async getAnalyticsGaps(project, window) {
+    const qs = window ? `?window=${encodeURIComponent(window)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/analytics/gaps${qs}`);
+  }
+  async getAnalyticsSources(project, window) {
+    const qs = window ? `?window=${encodeURIComponent(window)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/analytics/sources${qs}`);
+  }
+  // Google Indexing API
+  async googleRequestIndexing(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/google/indexing/request`, body);
+  }
+  // Bing Webmaster Tools
+  async bingConnect(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/bing/connect`, body);
+  }
+  async bingDisconnect(project) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/bing/disconnect`);
+  }
+  async bingStatus(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/bing/status`);
+  }
+  async bingSites(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/bing/sites`);
+  }
+  async bingSetSite(project, siteUrl) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/bing/set-site`, { siteUrl });
+  }
+  async bingCoverage(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/bing/coverage`);
+  }
+  async bingCoverageHistory(project, params) {
+    const qs = params?.limit != null ? `?limit=${params.limit}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/bing/coverage/history${qs}`);
+  }
+  async bingInspections(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/bing/inspections${qs}`);
+  }
+  async bingInspectUrl(project, url) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/bing/inspect-url`, { url });
+  }
+  async bingInspectSitemap(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/bing/inspect-sitemap`, body ?? {});
+  }
+  async bingRequestIndexing(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/bing/request-indexing`, body);
+  }
+  async bingPerformance(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/bing/performance${qs}`);
+  }
+  // CDP browser provider
+  async getCdpStatus() {
+    return this.request("GET", "/cdp/status");
+  }
+  async cdpScreenshot(query, targets) {
+    return this.request("POST", "/cdp/screenshot", { query, targets });
+  }
+  async getBrowserDiff(project, runId) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/runs/${encodeURIComponent(runId)}/browser-diff`);
+  }
+  // Google Analytics 4
+  async gaConnect(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/ga/connect`, body);
+  }
+  async gaDisconnect(project) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/ga/disconnect`);
+  }
+  async gaStatus(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/status`);
+  }
+  async gaSync(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/ga/sync`, body ?? {});
+  }
+  async gaTraffic(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/traffic${qs}`);
+  }
+  async gaCoverage(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/coverage`);
+  }
+  async gaAiReferralHistory(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/ai-referral-history${qs}`);
+  }
+  async gaSocialReferralHistory(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/social-referral-history${qs}`);
+  }
+  async gaSocialReferralTrend(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/social-referral-trend`);
+  }
+  async gaAttributionTrend(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/attribution-trend`);
+  }
+  async gaSessionHistory(project, params) {
+    const qs = params ? "?" + new URLSearchParams(params).toString() : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/ga/session-history${qs}`);
+  }
+  async wordpressConnect(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/connect`, body);
+  }
+  async wordpressDisconnect(project) {
+    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/wordpress/disconnect`);
+  }
+  async wordpressStatus(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/status`);
+  }
+  async wordpressPages(project, env) {
+    const qs = env ? `?env=${encodeURIComponent(env)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/pages${qs}`);
+  }
+  async wordpressPage(project, slug, env) {
+    const params = new URLSearchParams({ slug });
+    if (env) params.set("env", env);
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/page?${params.toString()}`);
+  }
+  async wordpressCreatePage(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/pages`, body);
+  }
+  async wordpressUpdatePage(project, body) {
+    return this.request("PUT", `/projects/${encodeURIComponent(project)}/wordpress/page`, body);
+  }
+  async wordpressSetMeta(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/page/meta`, body);
+  }
+  async wordpressBulkSetMeta(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/pages/meta/bulk`, body);
+  }
+  async wordpressSchema(project, slug, env) {
+    const params = new URLSearchParams({ slug });
+    if (env) params.set("env", env);
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/schema?${params.toString()}`);
+  }
+  async wordpressSetSchema(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/schema/manual`, body);
+  }
+  async wordpressSchemaDeploy(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/schema/deploy`, body);
+  }
+  async wordpressSchemaStatus(project, env) {
+    const params = new URLSearchParams();
+    if (env) params.set("env", env);
+    const qs = params.toString();
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/schema/status${qs ? `?${qs}` : ""}`);
+  }
+  async wordpressOnboard(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/onboard`, body);
+  }
+  async wordpressLlmsTxt(project, env) {
+    const qs = env ? `?env=${encodeURIComponent(env)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/llms-txt${qs}`);
+  }
+  async wordpressSetLlmsTxt(project, body) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/llms-txt/manual`, body);
+  }
+  async wordpressAudit(project, env) {
+    const qs = env ? `?env=${encodeURIComponent(env)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/audit${qs}`);
+  }
+  async wordpressDiff(project, slug) {
+    const params = new URLSearchParams({ slug });
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/diff?${params.toString()}`);
+  }
+  async wordpressStagingStatus(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/wordpress/staging/status`);
+  }
+  async wordpressStagingPush(project) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/wordpress/staging/push`);
+  }
+  // ── Intelligence ──────────────────────────────────────────────────────
+  async getInsights(project, opts) {
+    const params = new URLSearchParams();
+    if (opts?.dismissed) params.set("dismissed", "true");
+    if (opts?.runId) params.set("runId", opts.runId);
+    const qs = params.toString();
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/insights${qs ? `?${qs}` : ""}`);
+  }
+  async getInsight(project, id) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/insights/${encodeURIComponent(id)}`);
+  }
+  async dismissInsight(project, id) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/insights/${encodeURIComponent(id)}/dismiss`);
+  }
+  async getHealth(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/health/latest`);
+  }
+  async getHealthHistory(project, limit) {
+    const qs = limit ? `?limit=${limit}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/health/history${qs}`);
+  }
+  // --- Backlinks ---------------------------------------------------------
+  async backlinksStatus() {
+    return this.request("GET", "/backlinks/status");
+  }
+  async backlinksInstall() {
+    return this.request("POST", "/backlinks/install");
+  }
+  async backlinksTriggerSync(release) {
+    return this.request("POST", "/backlinks/syncs", { release });
+  }
+  async backlinksLatestSync() {
+    return this.request("GET", "/backlinks/syncs/latest");
+  }
+  async backlinksListSyncs() {
+    return this.request("GET", "/backlinks/syncs");
+  }
+  async backlinksCachedReleases() {
+    return this.request("GET", "/backlinks/releases");
+  }
+  async backlinksPruneCache(release) {
+    return this.request("DELETE", `/backlinks/cache/${encodeURIComponent(release)}`);
+  }
+  async backlinksExtract(project, release) {
+    return this.request("POST", `/projects/${encodeURIComponent(project)}/backlinks/extract`, release ? { release } : {});
+  }
+  async backlinksSummary(project, release) {
+    const qs = release ? `?release=${encodeURIComponent(release)}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/backlinks/summary${qs}`);
+  }
+  async backlinksDomains(project, opts = {}) {
+    const qs = new URLSearchParams();
+    if (opts.limit !== void 0) qs.set("limit", String(opts.limit));
+    if (opts.offset !== void 0) qs.set("offset", String(opts.offset));
+    if (opts.release) qs.set("release", opts.release);
+    const suffix = qs.toString() ? `?${qs.toString()}` : "";
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/backlinks/domains${suffix}`);
+  }
+  async backlinksHistory(project) {
+    return this.request("GET", `/projects/${encodeURIComponent(project)}/backlinks/history`);
+  }
+};
+
+export {
+  getConfigDir,
+  getConfigPath,
+  loadConfig,
+  saveConfig,
+  saveConfigPatch,
+  configExists,
+  EXIT_SYSTEM_ERROR,
+  CliError,
+  usageError,
+  isEndpointMissing,
+  printCliError,
+  providerQuotaPolicySchema,
+  ProviderNames,
+  isBrowserProvider,
+  resolveProviderInput,
+  locationContextSchema,
+  notificationEventSchema,
+  notificationCreateRequestSchema,
+  findDuplicateLocationLabels,
+  hasLocationLabel,
+  projectUpsertRequestSchema,
+  keywordBatchRequestSchema,
+  keywordGenerateRequestSchema,
+  competitorBatchRequestSchema,
+  normalizeProjectDomain,
+  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,
+  runTriggerRequestSchema,
+  snapshotRequestSchema,
+  scheduleUpsertRequestSchema,
+  parseWindow,
+  windowCutoff,
+  categorizeSource,
+  categoryLabel,
+  extractAnswerMentions,
+  determineAnswerMentioned,
+  visibilityStateFromAnswerMentioned,
+  brandKeyFromText,
+  MemorySources,
+  AGENT_MEMORY_VALUE_MAX_BYTES,
+  AGENT_MEMORY_KEY_MAX_LENGTH,
+  agentMemoryUpsertRequestSchema,
+  agentMemoryDeleteRequestSchema,
+  CcReleaseSyncStatuses,
+  createApiClient,
+  ApiClient
+};