@ainyc/canonry 2.5.1 → 2.8.2

package/dist/{chunk-CFS35BKX.js → chunk-MGBXRWLX.js}

@@ -1,3 +1,57 @@
+import {
+  AGENT_MEMORY_KEY_MAX_LENGTH,
+  AGENT_MEMORY_VALUE_MAX_BYTES,
+  AGENT_PROVIDER_IDS,
+  AgentProviderIds,
+  ApiClient,
+  AppError,
+  CcReleaseSyncStatuses,
+  MemorySources,
+  RunKinds,
+  RunStatuses,
+  RunTriggers,
+  agentBusy,
+  agentMemoryDeleteRequestSchema,
+  agentMemoryUpsertRequestSchema,
+  authInvalid,
+  authRequired,
+  brandKeyFromText,
+  categorizeSource,
+  categoryLabel,
+  competitorBatchRequestSchema,
+  configExists,
+  deliveryFailed,
+  determineAnswerMentioned,
+  effectiveDomains,
+  extractAnswerMentions,
+  findDuplicateLocationLabels,
+  hasLocationLabel,
+  internalError,
+  isAgentProviderId,
+  isBrowserProvider,
+  keywordGenerateRequestSchema,
+  loadConfig,
+  locationContextSchema,
+  missingDependency,
+  normalizeProjectDomain,
+  notFound,
+  notImplemented,
+  parseWindow,
+  projectConfigSchema,
+  projectUpsertRequestSchema,
+  providerError,
+  runInProgress,
+  runNotCancellable,
+  runTriggerRequestSchema,
+  saveConfigPatch,
+  scheduleUpsertRequestSchema,
+  snapshotRequestSchema,
+  unsupportedKind,
+  validationError,
+  visibilityStateFromAnswerMentioned,
+  windowCutoff,
+  wordpressEnvSchema
+} from "./chunk-FPZUQADO.js";
 import {
   IntelligenceService,
   agentMemory,
@@ -30,172 +84,7 @@ import {
   runs,
   schedules,
   usageCounters
-} from "./chunk-32YTAZBL.js";
-
-// 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());
-}
+} from "./chunk-PYHANJ3B.js";
 
 // src/telemetry.ts
 import crypto from "crypto";
@@ -269,1259 +158,15 @@ function trackEvent(event, properties) {
   }).finally(() => clearTimeout(timeout));
 }
 
-// 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");
-}
-
 // src/server.ts
 import { createRequire as createRequire3 } from "module";
 import crypto28 from "crypto";
-import fs13 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path14 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { eq as eq30 } from "drizzle-orm";
 import Fastify from "fastify";
 
-// ../contracts/src/config-schema.ts
-import { z as z4 } 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/notification.ts
-import { z as z2 } from "zod";
-var notificationEventSchema = z2.enum([
-  "citation.lost",
-  "citation.gained",
-  "run.completed",
-  "run.failed",
-  "insight.critical",
-  "insight.high"
-]);
-var notificationDtoSchema = z2.object({
-  id: z2.string(),
-  projectId: z2.string(),
-  channel: z2.literal("webhook"),
-  url: z2.string().url(),
-  urlDisplay: z2.string(),
-  urlHost: z2.string(),
-  events: z2.array(notificationEventSchema),
-  enabled: z2.boolean().default(true),
-  /** Opaque tag identifying the creator (e.g. `"agent"` for Aero webhooks). */
-  source: z2.string().optional(),
-  webhookSecret: z2.string().optional(),
-  createdAt: z2.string(),
-  updatedAt: z2.string()
-});
-
-// ../contracts/src/project.ts
-import { z as z3 } from "zod";
-var configSourceSchema = z3.enum(["cli", "api", "config-file"]);
-function findDuplicateLocationLabels(locations) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = /* @__PURE__ */ new Set();
-  for (const location of locations) {
-    if (seen.has(location.label)) {
-      duplicates.add(location.label);
-      continue;
-    }
-    seen.add(location.label);
-  }
-  return [...duplicates];
-}
-function hasLocationLabel(locations, label) {
-  if (!label) return true;
-  return locations.some((location) => location.label === label);
-}
-var projectUpsertRequestSchema = z3.object({
-  displayName: z3.string().min(1),
-  canonicalDomain: z3.string().min(1),
-  ownedDomains: z3.array(z3.string().min(1)).optional(),
-  country: z3.string().length(2),
-  language: z3.string().min(2),
-  tags: z3.array(z3.string()).optional(),
-  labels: z3.record(z3.string(), z3.string()).optional(),
-  providers: z3.array(providerNameSchema).optional(),
-  locations: z3.array(locationContextSchema).optional(),
-  defaultLocation: z3.string().nullable().optional(),
-  autoExtractBacklinks: z3.boolean().optional(),
-  configSource: configSourceSchema.optional()
-});
-var projectDtoSchema = z3.object({
-  id: z3.string(),
-  name: z3.string(),
-  displayName: z3.string().optional(),
-  canonicalDomain: z3.string(),
-  ownedDomains: z3.array(z3.string()).default([]),
-  country: z3.string().length(2),
-  language: z3.string().min(2),
-  tags: z3.array(z3.string()).default([]),
-  labels: z3.record(z3.string(), z3.string()).default({}),
-  locations: z3.array(locationContextSchema).default([]),
-  defaultLocation: z3.string().nullable().optional(),
-  autoExtractBacklinks: z3.boolean().default(false),
-  configSource: configSourceSchema.default("cli"),
-  configRevision: z3.number().int().positive().default(1),
-  createdAt: z3.string().optional(),
-  updatedAt: z3.string().optional()
-});
-function normalizeProjectDomain(input) {
-  let domain = input.trim().toLowerCase();
-  try {
-    if (domain.includes("://")) {
-      domain = new URL(domain).hostname.toLowerCase();
-    }
-  } catch {
-  }
-  return domain.replace(/^www\./, "");
-}
-function effectiveDomains(project) {
-  const all = [project.canonicalDomain, ...project.ownedDomains ?? []];
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const d of all) {
-    const trimmed = d.trim();
-    if (!trimmed) continue;
-    const norm = normalizeProjectDomain(trimmed);
-    if (seen.has(norm)) continue;
-    seen.add(norm);
-    result.push(trimmed);
-  }
-  return result;
-}
-
-// ../contracts/src/config-schema.ts
-var configMetadataSchema = z4.object({
-  name: z4.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, {
-    message: "Name must be a lowercase slug (letters, numbers, hyphens)"
-  }),
-  labels: z4.record(z4.string(), z4.string()).optional().default({})
-});
-var configScheduleSchema = z4.object({
-  preset: z4.string().optional(),
-  cron: z4.string().optional(),
-  timezone: z4.string().optional().default("UTC"),
-  providers: z4.array(providerNameSchema).optional().default([])
-}).refine(
-  (data) => data.preset && !data.cron || !data.preset && data.cron,
-  { message: 'Exactly one of "preset" or "cron" must be provided' }
-).optional();
-var configNotificationSchema = z4.object({
-  channel: z4.literal("webhook"),
-  url: z4.string().url(),
-  events: z4.array(notificationEventSchema).min(1)
-});
-var configGoogleSchema = z4.object({
-  gsc: z4.object({
-    propertyUrl: z4.string()
-  }).optional(),
-  syncSchedule: z4.object({
-    preset: z4.string().optional(),
-    cron: z4.string().optional()
-  }).optional()
-}).optional();
-var configSpecSchema = z4.object({
-  displayName: z4.string().min(1),
-  canonicalDomain: z4.string().min(1),
-  ownedDomains: z4.array(z4.string().min(1)).optional().default([]),
-  country: z4.string().length(2),
-  language: z4.string().min(2),
-  keywords: z4.array(z4.string().min(1)).optional().default([]),
-  competitors: z4.array(z4.string().min(1)).optional().default([]),
-  providers: z4.array(providerNameSchema).optional().default([]),
-  locations: z4.array(locationContextSchema).optional().default([]),
-  defaultLocation: z4.string().optional(),
-  schedule: configScheduleSchema,
-  notifications: z4.array(configNotificationSchema).optional().default([]),
-  google: configGoogleSchema,
-  autoExtractBacklinks: z4.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 = z4.object({
-  apiVersion: z4.literal("canonry/v1"),
-  kind: z4.literal("Project"),
-  metadata: configMetadataSchema,
-  spec: configSpecSchema
-});
-
-// ../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/google.ts
-import { z as z5 } from "zod";
-var googleConnectionTypeSchema = z5.enum(["gsc", "ga4"]);
-var googleConnectionDtoSchema = z5.object({
-  id: z5.string(),
-  domain: z5.string(),
-  connectionType: googleConnectionTypeSchema,
-  propertyId: z5.string().nullable().optional(),
-  sitemapUrl: z5.string().nullable().optional(),
-  scopes: z5.array(z5.string()).default([]),
-  createdAt: z5.string(),
-  updatedAt: z5.string()
-});
-var gscSearchDataDtoSchema = z5.object({
-  date: z5.string(),
-  query: z5.string(),
-  page: z5.string(),
-  country: z5.string().nullable().optional(),
-  device: z5.string().nullable().optional(),
-  clicks: z5.number(),
-  impressions: z5.number(),
-  ctr: z5.number(),
-  position: z5.number()
-});
-var gscUrlInspectionDtoSchema = z5.object({
-  id: z5.string(),
-  url: z5.string(),
-  indexingState: z5.string().nullable().optional(),
-  verdict: z5.string().nullable().optional(),
-  coverageState: z5.string().nullable().optional(),
-  pageFetchState: z5.string().nullable().optional(),
-  robotsTxtState: z5.string().nullable().optional(),
-  crawlTime: z5.string().nullable().optional(),
-  lastCrawlResult: z5.string().nullable().optional(),
-  isMobileFriendly: z5.boolean().nullable().optional(),
-  richResults: z5.array(z5.string()).default([]),
-  inspectedAt: z5.string()
-});
-var indexTransitionSchema = z5.enum(["stable", "reindexed", "deindexed", "still-missing", "new"]);
-var gscDeindexedRowSchema = z5.object({
-  url: z5.string(),
-  previousState: z5.string().nullable(),
-  currentState: z5.string().nullable(),
-  transitionDate: z5.string()
-});
-var gscReasonGroupSchema = z5.object({
-  reason: z5.string(),
-  count: z5.number(),
-  urls: z5.array(gscUrlInspectionDtoSchema).default([])
-});
-var gscCoverageSummaryDtoSchema = z5.object({
-  summary: z5.object({
-    total: z5.number(),
-    indexed: z5.number(),
-    notIndexed: z5.number(),
-    deindexed: z5.number(),
-    percentage: z5.number()
-  }),
-  lastInspectedAt: z5.string().nullable(),
-  indexed: z5.array(gscUrlInspectionDtoSchema).default([]),
-  notIndexed: z5.array(gscUrlInspectionDtoSchema).default([]),
-  deindexed: z5.array(gscDeindexedRowSchema).default([]),
-  reasonGroups: z5.array(gscReasonGroupSchema).default([])
-});
-var indexingNotificationDtoSchema = z5.object({
-  url: z5.string(),
-  type: z5.enum(["URL_UPDATED", "URL_DELETED"]),
-  notifiedAt: z5.string()
-});
-var indexingRequestResultDtoSchema = z5.object({
-  url: z5.string(),
-  type: z5.enum(["URL_UPDATED", "URL_DELETED"]),
-  notifiedAt: z5.string(),
-  status: z5.enum(["success", "error"]),
-  error: z5.string().optional()
-});
-var gscCoverageSnapshotDtoSchema = z5.object({
-  date: z5.string(),
-  indexed: z5.number(),
-  notIndexed: z5.number(),
-  reasonBreakdown: z5.record(z5.string(), z5.number()).default({})
-});
-
-// ../contracts/src/bing.ts
-import { z as z6 } from "zod";
-var bingConnectionDtoSchema = z6.object({
-  id: z6.string(),
-  domain: z6.string(),
-  siteUrl: z6.string().nullable().optional(),
-  createdAt: z6.string(),
-  updatedAt: z6.string()
-});
-var bingUrlInspectionDtoSchema = z6.object({
-  id: z6.string(),
-  url: z6.string(),
-  httpCode: z6.number().nullable().optional(),
-  inIndex: z6.boolean().nullable().optional(),
-  lastCrawledDate: z6.string().nullable().optional(),
-  inIndexDate: z6.string().nullable().optional(),
-  inspectedAt: z6.string(),
-  // Fields derived from GetUrlInfo response (more reliable than InIndex)
-  documentSize: z6.number().nullable().optional(),
-  anchorCount: z6.number().nullable().optional(),
-  discoveryDate: z6.string().nullable().optional()
-});
-var bingCoverageSummaryDtoSchema = z6.object({
-  summary: z6.object({
-    total: z6.number(),
-    indexed: z6.number(),
-    notIndexed: z6.number(),
-    unknown: z6.number().optional(),
-    percentage: z6.number()
-  }),
-  lastInspectedAt: z6.string().nullable(),
-  indexed: z6.array(bingUrlInspectionDtoSchema).default([]),
-  notIndexed: z6.array(bingUrlInspectionDtoSchema).default([]),
-  unknown: z6.array(bingUrlInspectionDtoSchema).default([]).optional()
-});
-var bingKeywordStatsDtoSchema = z6.object({
-  query: z6.string(),
-  impressions: z6.number(),
-  clicks: z6.number(),
-  ctr: z6.number(),
-  averagePosition: z6.number()
-});
-var bingCoverageSnapshotDtoSchema = z6.object({
-  date: z6.string(),
-  indexed: z6.number(),
-  notIndexed: z6.number(),
-  unknown: z6.number()
-});
-var bingSubmitResultDtoSchema = z6.object({
-  url: z6.string(),
-  status: z6.enum(["success", "error"]),
-  submittedAt: z6.string(),
-  error: z6.string().optional()
-});
-
-// ../contracts/src/wordpress.ts
-import { z as z7 } from "zod";
-var wordpressEnvSchema = z7.enum(["live", "staging"]);
-var wordpressConnectionDtoSchema = z7.object({
-  projectName: z7.string(),
-  url: z7.string(),
-  stagingUrl: z7.string().optional(),
-  username: z7.string(),
-  defaultEnv: wordpressEnvSchema,
-  createdAt: z7.string(),
-  updatedAt: z7.string()
-});
-var wordpressSiteStatusDtoSchema = z7.object({
-  url: z7.string(),
-  reachable: z7.boolean(),
-  pageCount: z7.number().nullable().optional(),
-  version: z7.string().nullable().optional(),
-  error: z7.string().nullable().optional(),
-  plugins: z7.array(z7.string()).optional(),
-  authenticatedUser: z7.object({
-    id: z7.number(),
-    slug: z7.string()
-  }).nullable().optional()
-});
-var wordpressStatusDtoSchema = z7.object({
-  connected: z7.boolean(),
-  projectName: z7.string(),
-  defaultEnv: wordpressEnvSchema,
-  live: wordpressSiteStatusDtoSchema.nullable(),
-  staging: wordpressSiteStatusDtoSchema.nullable(),
-  adminUrl: z7.string().nullable().optional()
-});
-var wordpressPageSummaryDtoSchema = z7.object({
-  id: z7.number(),
-  slug: z7.string(),
-  title: z7.string(),
-  status: z7.string(),
-  modifiedAt: z7.string().nullable().optional(),
-  link: z7.string().nullable().optional()
-});
-var wordpressSeoStateDtoSchema = z7.object({
-  title: z7.string().nullable(),
-  description: z7.string().nullable(),
-  noindex: z7.boolean().nullable(),
-  writable: z7.boolean().default(false),
-  writeTargets: z7.array(z7.string()).default([])
-});
-var wordpressSchemaBlockDtoSchema = z7.object({
-  type: z7.string(),
-  json: z7.record(z7.string(), z7.unknown())
-});
-var wordpressPageDetailDtoSchema = wordpressPageSummaryDtoSchema.extend({
-  env: wordpressEnvSchema,
-  content: z7.string(),
-  seo: wordpressSeoStateDtoSchema,
-  schemaBlocks: z7.array(wordpressSchemaBlockDtoSchema).default([])
-});
-var wordpressDiffPageDtoSchema = wordpressPageDetailDtoSchema.extend({
-  contentHash: z7.string(),
-  contentSnippet: z7.string()
-});
-var wordpressManualAssistDtoSchema = z7.object({
-  manualRequired: z7.literal(true),
-  targetUrl: z7.string(),
-  adminUrl: z7.string().nullable().optional(),
-  content: z7.string(),
-  nextSteps: z7.array(z7.string()).default([])
-});
-var wordpressAuditIssueDtoSchema = z7.object({
-  slug: z7.string(),
-  severity: z7.enum(["high", "medium", "low"]),
-  code: z7.enum([
-    "noindex",
-    "missing-seo-title",
-    "missing-meta-description",
-    "missing-schema",
-    "thin-content"
-  ]),
-  message: z7.string()
-});
-var wordpressAuditPageDtoSchema = z7.object({
-  slug: z7.string(),
-  title: z7.string(),
-  status: z7.string(),
-  wordCount: z7.number(),
-  seo: wordpressSeoStateDtoSchema,
-  schemaPresent: z7.boolean(),
-  issues: z7.array(wordpressAuditIssueDtoSchema).default([])
-});
-var wordpressBulkMetaEntryResultDtoSchema = z7.object({
-  slug: z7.string(),
-  status: z7.enum(["applied", "skipped", "manual"]),
-  error: z7.string().optional(),
-  manualAssist: wordpressManualAssistDtoSchema.optional()
-});
-var wordpressBulkMetaResultDtoSchema = z7.object({
-  env: wordpressEnvSchema,
-  strategy: z7.enum(["plugin", "manual"]),
-  results: z7.array(wordpressBulkMetaEntryResultDtoSchema)
-});
-var wordpressSchemaDeployEntryResultDtoSchema = z7.object({
-  slug: z7.string(),
-  status: z7.enum(["deployed", "stripped", "skipped", "failed"]),
-  schemasInjected: z7.array(z7.string()).optional(),
-  manualAssist: wordpressManualAssistDtoSchema.optional(),
-  error: z7.string().optional()
-});
-var wordpressSchemaDeployResultDtoSchema = z7.object({
-  env: wordpressEnvSchema,
-  results: z7.array(wordpressSchemaDeployEntryResultDtoSchema)
-});
-var wordpressSchemaStatusPageDtoSchema = z7.object({
-  slug: z7.string(),
-  title: z7.string(),
-  canonrySchemas: z7.array(z7.string()),
-  thirdPartySchemas: z7.array(z7.string()),
-  hasCanonrySchema: z7.boolean()
-});
-var wordpressSchemaStatusResultDtoSchema = z7.object({
-  env: wordpressEnvSchema,
-  pages: z7.array(wordpressSchemaStatusPageDtoSchema)
-});
-var wordpressOnboardStepDtoSchema = z7.object({
-  name: z7.string(),
-  status: z7.enum(["completed", "skipped", "failed"]),
-  summary: z7.string().optional(),
-  error: z7.string().optional()
-});
-var wordpressOnboardResultDtoSchema = z7.object({
-  projectName: z7.string(),
-  steps: z7.array(wordpressOnboardStepDtoSchema)
-});
-var wordpressDiffDtoSchema = z7.object({
-  slug: z7.string(),
-  live: wordpressDiffPageDtoSchema,
-  staging: wordpressDiffPageDtoSchema,
-  hasDifferences: z7.boolean(),
-  differences: z7.object({
-    title: z7.boolean(),
-    slug: z7.boolean(),
-    content: z7.boolean(),
-    seoTitle: z7.boolean(),
-    seoDescription: z7.boolean(),
-    noindex: z7.boolean(),
-    schema: z7.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/run.ts
-import { z as z8 } from "zod";
-var runStatusSchema = z8.enum(["queued", "running", "completed", "partial", "failed", "cancelled"]);
-var RunStatuses = runStatusSchema.enum;
-var runKindSchema = z8.enum([
-  "answer-visibility",
-  "site-audit",
-  "gsc-sync",
-  "inspect-sitemap",
-  "ga-sync",
-  "bing-inspect",
-  "bing-inspect-sitemap",
-  "backlink-extract"
-]);
-var RunKinds = runKindSchema.enum;
-var runTriggerSchema = z8.enum(["manual", "scheduled", "config-apply"]);
-var RunTriggers = runTriggerSchema.enum;
-var citationStateSchema = z8.enum(["cited", "not-cited"]);
-var CitationStates = citationStateSchema.enum;
-var visibilityStateSchema = z8.enum(["visible", "not-visible"]);
-var VisibilityStates = visibilityStateSchema.enum;
-var computedTransitionSchema = z8.enum(["new", "cited", "lost", "emerging", "not-cited"]);
-var ComputedTransitions = computedTransitionSchema.enum;
-var runDtoSchema = z8.object({
-  id: z8.string(),
-  projectId: z8.string(),
-  kind: runKindSchema,
-  status: runStatusSchema,
-  trigger: runTriggerSchema.default("manual"),
-  location: z8.string().nullable().optional(),
-  startedAt: z8.string().nullable().optional(),
-  finishedAt: z8.string().nullable().optional(),
-  error: z8.string().nullable().optional(),
-  createdAt: z8.string()
-});
-var groundingSourceSchema = z8.object({
-  uri: z8.string(),
-  title: z8.string()
-});
-var querySnapshotDtoSchema = z8.object({
-  id: z8.string(),
-  runId: z8.string(),
-  keywordId: z8.string(),
-  keyword: z8.string().optional(),
-  provider: providerNameSchema,
-  citationState: citationStateSchema,
-  answerMentioned: z8.boolean().optional(),
-  visibilityState: visibilityStateSchema.optional(),
-  transition: computedTransitionSchema.optional(),
-  answerText: z8.string().nullable().optional(),
-  citedDomains: z8.array(z8.string()).default([]),
-  competitorOverlap: z8.array(z8.string()).default([]),
-  recommendedCompetitors: z8.array(z8.string()).default([]),
-  matchedTerms: z8.array(z8.string()).default([]),
-  groundingSources: z8.array(groundingSourceSchema).default([]),
-  searchQueries: z8.array(z8.string()).default([]),
-  model: z8.string().nullable().optional(),
-  location: z8.string().nullable().optional(),
-  createdAt: z8.string()
-});
-var runDetailDtoSchema = runDtoSchema.extend({
-  snapshots: z8.array(querySnapshotDtoSchema).optional()
-});
-var latestProjectRunDtoSchema = z8.object({
-  totalRuns: z8.number().int().nonnegative(),
-  run: runDetailDtoSchema.nullable()
-});
-var auditLogEntrySchema = z8.object({
-  id: z8.string(),
-  projectId: z8.string().nullable().optional(),
-  actor: z8.string(),
-  action: z8.string(),
-  entityType: z8.string(),
-  entityId: z8.string().nullable().optional(),
-  diff: z8.unknown().optional(),
-  createdAt: z8.string()
-});
-
-// ../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 domainMatches3 = unique.filter((t) => t.includes("."));
-  const dedupedFinal = unique.filter((term) => {
-    if (term.includes(".")) return true;
-    return !domainMatches3.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()
-});
-
 // ../api-routes/src/auth.ts
 import crypto2 from "crypto";
 import { eq } from "drizzle-orm";
@@ -2017,10 +662,16 @@ async function keywordRoutes(app, opts) {
   });
   app.post("/projects/:name/keywords/generate", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const body = request.body;
-    if (!body?.provider || typeof body.provider !== "string") {
-      throw validationError('Body must contain a "provider" string');
+    const parsed = keywordGenerateRequestSchema.safeParse(request.body);
+    if (!parsed.success) {
+      throw validationError("Invalid keyword generation request", {
+        issues: parsed.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message
+        }))
+      });
     }
+    const body = parsed.data;
     const provider = body.provider.trim().toLowerCase();
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && !validNames.includes(provider)) {
@@ -2029,10 +680,7 @@ async function keywordRoutes(app, opts) {
         validProviders: validNames
       });
     }
-    if (body.count !== void 0 && (typeof body.count !== "number" || !Number.isFinite(body.count) || !Number.isInteger(body.count))) {
-      throw validationError('"count" must be an integer');
-    }
-    const count = Math.min(Math.max(body.count ?? 5, 1), 20);
+    const count = body.count ?? 5;
     if (!opts.onGenerateKeywords) {
       throw notImplemented("Key phrase generation is not supported in this deployment");
     }
@@ -2091,6 +739,79 @@ async function competitorRoutes(app) {
     const rows = app.db.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
   });
+  app.post("/projects/:name/competitors", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const body = parseCompetitorBatch(request.body);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const requested = uniqueStrings(body.competitors);
+    app.db.transaction((tx) => {
+      const existing = tx.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
+      const existingSet = new Set(existing.map((c) => c.domain));
+      const added = requested.filter((domain) => !existingSet.has(domain));
+      if (added.length === 0) return;
+      for (const domain of added) {
+        tx.insert(competitors).values({
+          id: crypto6.randomUUID(),
+          projectId: project.id,
+          domain,
+          createdAt: now
+        }).onConflictDoNothing({
+          target: [competitors.projectId, competitors.domain]
+        }).run();
+      }
+      writeAuditLog(tx, {
+        projectId: project.id,
+        actor: "api",
+        action: "competitors.appended",
+        entityType: "competitor",
+        diff: { added }
+      });
+    });
+    const rows = app.db.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
+  });
+  app.delete("/projects/:name/competitors", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const body = parseCompetitorBatch(request.body);
+    const requested = new Set(uniqueStrings(body.competitors));
+    app.db.transaction((tx) => {
+      const existing = tx.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
+      const rowsToDelete = existing.filter((c) => requested.has(c.domain));
+      if (rowsToDelete.length === 0) return;
+      for (const row of rowsToDelete) {
+        tx.delete(competitors).where(eq5(competitors.id, row.id)).run();
+      }
+      writeAuditLog(tx, {
+        projectId: project.id,
+        actor: "api",
+        action: "competitors.deleted",
+        entityType: "competitor",
+        diff: { deleted: rowsToDelete.map((row) => row.domain) }
+      });
+    });
+    const rows = app.db.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
+    return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
+  });
+}
+function parseCompetitorBatch(value) {
+  const result = competitorBatchRequestSchema.safeParse(value);
+  if (result.success) return result.data;
+  throw validationError("Invalid competitor batch request", {
+    issues: result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }))
+  });
+}
+function uniqueStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    result.push(value);
+  }
+  return result;
 }
 
 // ../api-routes/src/runs.ts
@@ -2132,11 +853,11 @@ function queueRunIfProjectIdle(db, params) {
 async function runRoutes(app, opts) {
   app.post("/projects/:name/runs", async (request, reply) => {
     const project = resolveProject(app.db, request.params.name);
-    const kind = request.body?.kind ?? "answer-visibility";
-    if (kind !== "answer-visibility") throw unsupportedKind(kind);
+    const body = parseRunTriggerRequest(request.body ?? {});
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const trigger = request.body?.trigger ?? "manual";
-    const rawProviders = request.body?.providers;
+    const kind = body.kind ?? RunKinds["answer-visibility"];
+    const trigger = body.trigger ?? RunTriggers.manual;
+    const rawProviders = body.providers;
     if (rawProviders?.length) {
       const normalized = rawProviders.map((p) => p.trim().toLowerCase()).filter(Boolean);
       const validNames = opts.validProviderNames ?? [];
@@ -2154,13 +875,13 @@ async function runRoutes(app, opts) {
     const providers = rawProviders?.length ? rawProviders : void 0;
     let resolvedLocation;
     const projectLocations = parseJsonColumn(project.locations, []);
-    if (request.body?.noLocation) {
+    if (body.noLocation) {
       resolvedLocation = null;
-    } else if (request.body?.allLocations) {
-    } else if (request.body?.location) {
-      const loc = projectLocations.find((l) => l.label === request.body.location);
+    } else if (body.allLocations) {
+    } else if (body.location) {
+      const loc = projectLocations.find((l) => l.label === body.location);
       if (!loc) {
-        throw validationError(`Location "${request.body.location}" not found. Configure it first.`);
+        throw validationError(`Location "${body.location}" not found. Configure it first.`);
       }
       resolvedLocation = loc;
     } else if (project.defaultLocation) {
@@ -2170,7 +891,7 @@ async function runRoutes(app, opts) {
       }
       resolvedLocation = loc;
     }
-    if (request.body?.allLocations) {
+    if (body.allLocations) {
       if (projectLocations.length === 0) {
         throw validationError("No locations configured for this project");
       }
@@ -2339,6 +1060,16 @@ async function runRoutes(app, opts) {
     return reply.send(loadRunDetail(app, run));
   });
 }
+function parseRunTriggerRequest(value) {
+  const result = runTriggerRequestSchema.safeParse(value);
+  if (result.success) return result.data;
+  throw validationError("Invalid run trigger request", {
+    issues: result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }))
+  });
+}
 function formatRun(row) {
   return {
     id: row.id,
@@ -2550,7 +1281,7 @@ async function deliverWebhook(target, payload, webhookSecret) {
   const body = JSON.stringify(payload);
   const isHttps = target.url.protocol === "https:";
   const port = target.url.port ? Number(target.url.port) : isHttps ? 443 : 80;
-  const path16 = `${target.url.pathname}${target.url.search}`;
+  const path15 = `${target.url.pathname}${target.url.search}`;
   const headers = {
     "Content-Length": String(Buffer.byteLength(body)),
     "Content-Type": "application/json",
@@ -2566,7 +1297,7 @@ async function deliverWebhook(target, payload, webhookSecret) {
       headers,
       hostname: target.address,
       method: "POST",
-      path: path16,
+      path: path15,
       port,
       timeout: REQUEST_TIMEOUT_MS
     };
@@ -3604,7 +2335,7 @@ var booleanSchema = { type: "boolean" };
 var integerSchema = { type: "integer" };
 var objectSchema = { type: "object", additionalProperties: true };
 var stringArraySchema = { type: "array", items: stringSchema };
-var googleConnectionTypeSchema2 = { type: "string", enum: ["gsc", "ga4"] };
+var googleConnectionTypeSchema = { type: "string", enum: ["gsc", "ga4"] };
 var locationSchema = {
   type: "object",
   required: ["label", "city", "region", "country"],
@@ -3656,7 +2387,7 @@ var googleTypeParameter = {
   in: "path",
   required: true,
   description: "Google connection type.",
-  schema: googleConnectionTypeSchema2
+  schema: googleConnectionTypeSchema
 };
 var projectRunIdParameter = {
   name: "runId",
@@ -3964,32 +2695,81 @@ var routeCatalog = [
             type: "object",
             required: ["provider"],
             properties: {
-              provider: { type: "string", enum: ["gemini", "openai", "claude", "perplexity", "local"] },
-              count: integerSchema
+              provider: { type: "string", enum: ["gemini", "openai", "claude", "perplexity", "local"] },
+              count: integerSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Keyword suggestions returned." },
+      501: { description: "Keyword generation is not available." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/competitors",
+    summary: "List competitors",
+    tags: ["competitors"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Competitors returned." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/projects/{name}/competitors",
+    summary: "Replace competitors",
+    tags: ["competitors"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["competitors"],
+            properties: {
+              competitors: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Competitors replaced." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/competitors",
+    summary: "Append competitors",
+    tags: ["competitors"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["competitors"],
+            properties: {
+              competitors: stringArraySchema
             }
           }
         }
       }
     },
     responses: {
-      200: { description: "Keyword suggestions returned." },
-      501: { description: "Keyword generation is not available." }
-    }
-  },
-  {
-    method: "get",
-    path: "/api/v1/projects/{name}/competitors",
-    summary: "List competitors",
-    tags: ["competitors"],
-    parameters: [nameParameter],
-    responses: {
-      200: { description: "Competitors returned." }
+      200: { description: "Competitors appended." },
+      400: { description: "Invalid competitor append request." }
     }
   },
   {
-    method: "put",
+    method: "delete",
     path: "/api/v1/projects/{name}/competitors",
-    summary: "Replace competitors",
+    summary: "Delete specific competitors",
     tags: ["competitors"],
     parameters: [nameParameter],
     requestBody: {
@@ -4007,7 +2787,8 @@ var routeCatalog = [
       }
     },
     responses: {
-      200: { description: "Competitors replaced." }
+      200: { description: "Remaining competitors returned." },
+      400: { description: "Invalid competitor delete request." }
     }
   },
   {
@@ -4649,7 +3430,7 @@ var routeCatalog = [
             type: "object",
             required: ["type"],
             properties: {
-              type: googleConnectionTypeSchema2,
+              type: googleConnectionTypeSchema,
               propertyId: stringSchema,
               publicUrl: stringSchema
             }
@@ -6071,8 +4852,8 @@ async function openApiRoutes(app, opts = {}) {
     return reply.type("application/json").send(buildOpenApiDocument(opts));
   });
 }
-function buildOperationId(method, path16) {
-  const parts = path16.split("/").filter(Boolean).map((part) => {
+function buildOperationId(method, path15) {
+  const parts = path15.split("/").filter(Boolean).map((part) => {
     if (part.startsWith("{") && part.endsWith("}")) {
       return `by-${part.slice(1, -1)}`;
     }
@@ -6594,7 +5375,7 @@ async function exchangeCode(clientId, clientSecret, code, redirectUri) {
       const parsed = JSON.parse(body);
       if (parsed.error) detail = parsed.error;
       if (parsed.error_description) {
-        const sanitized = parsed.error_description.replace(new RegExp(escapeRegExp2(clientId), "g"), "***").replace(new RegExp(escapeRegExp2(clientSecret), "g"), "***").replace(new RegExp(escapeRegExp2(code), "g"), "***");
+        const sanitized = parsed.error_description.replace(new RegExp(escapeRegExp(clientId), "g"), "***").replace(new RegExp(escapeRegExp(clientSecret), "g"), "***").replace(new RegExp(escapeRegExp(code), "g"), "***");
         detail += detail ? `: ${sanitized}` : sanitized;
       }
     } catch {
@@ -6604,7 +5385,7 @@ async function exchangeCode(clientId, clientSecret, code, redirectUri) {
   }
   return await res.json();
 }
-function escapeRegExp2(str) {
+function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function refreshAccessToken(clientId, clientSecret, currentRefreshToken) {
@@ -6632,7 +5413,7 @@ async function refreshAccessToken(clientId, clientSecret, currentRefreshToken) {
       const parsed = JSON.parse(body);
       if (parsed.error) detail = parsed.error;
       if (parsed.error_description) {
-        const sanitized = parsed.error_description.replace(new RegExp(escapeRegExp2(clientId), "g"), "***").replace(new RegExp(escapeRegExp2(clientSecret), "g"), "***").replace(new RegExp(escapeRegExp2(currentRefreshToken), "g"), "***");
+        const sanitized = parsed.error_description.replace(new RegExp(escapeRegExp(clientId), "g"), "***").replace(new RegExp(escapeRegExp(clientSecret), "g"), "***").replace(new RegExp(escapeRegExp(currentRefreshToken), "g"), "***");
         detail += detail ? `: ${sanitized}` : sanitized;
       }
     } catch {
@@ -6946,13 +5727,13 @@ async function getAccessToken(clientEmail, privateKey) {
     const body = await res.text().catch(() => "");
     ga4Log("error", "token.failed", { httpStatus: res.status });
     const detail = body.length <= 200 ? body : `${body.slice(0, 200)}... [truncated]`;
-    const sanitizedDetail = detail.replace(new RegExp(escapeRegExp3(clientEmail), "g"), "***").replace(new RegExp(escapeRegExp3(privateKey.slice(0, 32)), "g"), "***");
+    const sanitizedDetail = detail.replace(new RegExp(escapeRegExp2(clientEmail), "g"), "***").replace(new RegExp(escapeRegExp2(privateKey.slice(0, 32)), "g"), "***");
     throw new GA4ApiError(`Failed to get access token: ${sanitizedDetail}`, res.status);
   }
   const data = await res.json();
   return data.access_token;
 }
-function escapeRegExp3(str) {
+function escapeRegExp2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function runReport(accessToken, propertyId, request) {
@@ -8082,7 +6863,7 @@ function bingClientLog(level, action, ctx) {
   const stream = level === "error" ? process.stderr : process.stdout;
   stream.write(JSON.stringify(entry) + "\n");
 }
-function escapeRegExp4(str) {
+function escapeRegExp3(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function bingFetch(apiKey, endpoint, opts) {
@@ -8110,7 +6891,7 @@ async function bingFetch(apiKey, endpoint, opts) {
     const body = await res.text();
     bingClientLog("error", "http.error", { endpoint, method, httpStatus: res.status });
     let detail = body.length <= 500 ? body : `${body.slice(0, 500)}... [truncated]`;
-    detail = detail.replace(new RegExp(escapeRegExp4(apiKey), "g"), "***");
+    detail = detail.replace(new RegExp(escapeRegExp3(apiKey), "g"), "***");
     throw new BingApiError(`Bing API error (${res.status}): ${detail}`, res.status);
   }
   const text = await res.text();
@@ -8654,12 +7435,12 @@ async function bingRoutes(app, opts) {
 }
 
 // ../api-routes/src/cdp.ts
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
+import fs from "fs";
+import path from "path";
+import os from "os";
 import { eq as eq16, and as and5 } from "drizzle-orm";
 function getScreenshotDir() {
-  return path2.join(os2.homedir(), ".canonry", "screenshots");
+  return path.join(os.homedir(), ".canonry", "screenshots");
 }
 async function cdpRoutes(app, opts) {
   app.get("/screenshots/:snapshotId", async (request, reply) => {
@@ -8669,17 +7450,17 @@ async function cdpRoutes(app, opts) {
       const err = notFound("Screenshot", snapshotId);
       return reply.code(err.statusCode).send(err.toJSON());
     }
-    const base = path2.resolve(getScreenshotDir());
-    const fullPath = path2.resolve(path2.join(base, snapshot.screenshotPath));
-    if (!fullPath.startsWith(base + path2.sep) && fullPath !== base) {
+    const base = path.resolve(getScreenshotDir());
+    const fullPath = path.resolve(path.join(base, snapshot.screenshotPath));
+    if (!fullPath.startsWith(base + path.sep) && fullPath !== base) {
       const err = notFound("Screenshot", snapshotId);
       return reply.code(err.statusCode).send(err.toJSON());
     }
-    if (!fs2.existsSync(fullPath)) {
+    if (!fs.existsSync(fullPath)) {
       const err = notFound("Screenshot file", snapshotId);
       return reply.code(err.statusCode).send(err.toJSON());
     }
-    const stream = fs2.createReadStream(fullPath);
+    const stream = fs.createReadStream(fullPath);
     return reply.type("image/png").send(stream);
   });
   app.put("/settings/cdp", async (request, reply) => {
@@ -9684,10 +8465,10 @@ function buildAuthErrorMessage(res, responseText) {
   }
   return "WordPress credentials are invalid or lack permission for this action";
 }
-async function fetchJson(connection, siteUrl, path16, init) {
+async function fetchJson(connection, siteUrl, path15, init) {
   if (siteUrl.startsWith("http:")) {
   }
-  const res = await fetch(`${normalizeSiteUrl(siteUrl)}${path16}`, {
+  const res = await fetch(`${normalizeSiteUrl(siteUrl)}${path15}`, {
     ...init,
     headers: {
       "Authorization": `Basic ${encodeBasicAuth(connection.username, connection.appPassword)}`,
@@ -10202,12 +8983,12 @@ var CANONRY_SCHEMA_START = "<!-- canonry:schema:start -->";
 var CANONRY_SCHEMA_END = "<!-- canonry:schema:end -->";
 function stripCanonrySchema(content) {
   const regex = new RegExp(
-    `${escapeRegExp5(CANONRY_SCHEMA_START)}[\\s\\S]*?${escapeRegExp5(CANONRY_SCHEMA_END)}`,
+    `${escapeRegExp4(CANONRY_SCHEMA_START)}[\\s\\S]*?${escapeRegExp4(CANONRY_SCHEMA_END)}`,
     "g"
   );
   return content.replace(regex, "").replace(/\n{3,}/g, "\n\n").trim();
 }
-function escapeRegExp5(str) {
+function escapeRegExp4(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function injectCanonrySchema(content, schemas) {
@@ -10314,7 +9095,7 @@ async function getSchemaStatus(connection, env) {
     const thirdPartySchemas = [];
     if (hasCanonryMarker) {
       const markerRegex = new RegExp(
-        `${escapeRegExp5(CANONRY_SCHEMA_START)}([\\s\\S]*?)${escapeRegExp5(CANONRY_SCHEMA_END)}`
+        `${escapeRegExp4(CANONRY_SCHEMA_START)}([\\s\\S]*?)${escapeRegExp4(CANONRY_SCHEMA_END)}`
       );
       const match = markerRegex.exec(rawContent);
       if (match?.[1]) {
@@ -11108,13 +9889,13 @@ import crypto18 from "crypto";
 import { and as and7, asc as asc2, desc as desc8, eq as eq18, sql as sql5 } from "drizzle-orm";
 
 // ../integration-commoncrawl/src/constants.ts
-import os3 from "os";
-import path3 from "path";
+import os2 from "os";
+import path2 from "path";
 var CC_BASE_URL = "https://data.commoncrawl.org/projects/hyperlinkgraph";
-var PLUGIN_DIR = path3.join(os3.homedir(), ".canonry", "plugins");
-var PLUGIN_PKG_JSON = path3.join(PLUGIN_DIR, "package.json");
+var PLUGIN_DIR = path2.join(os2.homedir(), ".canonry", "plugins");
+var PLUGIN_PKG_JSON = path2.join(PLUGIN_DIR, "package.json");
 var DUCKDB_SPEC = process.env.CANONRY_DUCKDB_SPEC ?? "@duckdb/node-api@1.4.4-r.3";
-var CC_CACHE_DIR = process.env.CANONRY_CC_CACHE_DIR ?? path3.join(os3.homedir(), ".canonry", "cache", "commoncrawl");
+var CC_CACHE_DIR = process.env.CANONRY_CC_CACHE_DIR ?? path2.join(os2.homedir(), ".canonry", "cache", "commoncrawl");
 var RELEASE_ID_REGEX = /^cc-main-(\d{4})-(jan-feb-mar|apr-may-jun|jul-aug-sep|oct-nov-dec)$/;
 function ccReleasePaths(release) {
   const base = `${CC_BASE_URL}/${release}/domain`;
@@ -11144,8 +9925,8 @@ function isValidReleaseId(id) {
 // ../integration-commoncrawl/src/downloader.ts
 import { createHash } from "crypto";
 import { createWriteStream } from "fs";
-import fs3 from "fs/promises";
-import path4 from "path";
+import fs2 from "fs/promises";
+import path3 from "path";
 import { pipeline } from "stream/promises";
 import { Readable, Transform } from "stream";
 async function downloadFile(opts) {
@@ -11153,7 +9934,7 @@ async function downloadFile(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const sidecarPath = `${opts.destPath}.sha256`;
   try {
-    const stat = await fs3.stat(opts.destPath);
+    const stat = await fs2.stat(opts.destPath);
     const sidecar = await readSidecar(sidecarPath);
     const sha2562 = sidecar ?? await hashFile(opts.destPath);
     if (!sidecar) await writeSidecar(sidecarPath, sha2562);
@@ -11161,7 +9942,7 @@ async function downloadFile(opts) {
   } catch {
   }
   const partialPath = `${opts.destPath}.partial`;
-  await fs3.mkdir(path4.dirname(opts.destPath), { recursive: true });
+  await fs2.mkdir(path3.dirname(opts.destPath), { recursive: true });
   await unlinkIfExists(partialPath);
   const res = await fetchImpl(opts.url);
   if (!res.ok || !res.body) {
@@ -11184,13 +9965,13 @@ async function downloadFile(opts) {
     createWriteStream(partialPath)
   );
   const sha256 = hasher.digest("hex");
-  await fs3.rename(partialPath, opts.destPath);
+  await fs2.rename(partialPath, opts.destPath);
   await writeSidecar(sidecarPath, sha256);
   return { bytes, sha256, cached: false, elapsedMs: Date.now() - start };
 }
 async function hashFile(filePath) {
   const hasher = createHash("sha256");
-  const handle = await fs3.open(filePath, "r");
+  const handle = await fs2.open(filePath, "r");
   try {
     const stream = handle.createReadStream();
     for await (const chunk of stream) hasher.update(chunk);
@@ -11201,7 +9982,7 @@ async function hashFile(filePath) {
 }
 async function readSidecar(sidecarPath) {
   try {
-    const raw = await fs3.readFile(sidecarPath, "utf8");
+    const raw = await fs2.readFile(sidecarPath, "utf8");
     const trimmed = raw.trim();
     return /^[0-9a-f]{64}$/i.test(trimmed) ? trimmed.toLowerCase() : null;
   } catch {
@@ -11209,12 +9990,12 @@ async function readSidecar(sidecarPath) {
   }
 }
 async function writeSidecar(sidecarPath, sha256) {
-  await fs3.writeFile(sidecarPath, `${sha256}
+  await fs2.writeFile(sidecarPath, `${sha256}
 `);
 }
 async function unlinkIfExists(p) {
   try {
-    await fs3.unlink(p);
+    await fs2.unlink(p);
   } catch {
   }
 }
@@ -11225,20 +10006,20 @@ function parseContentLength(value) {
 }
 
 // ../integration-commoncrawl/src/plugin-resolver.ts
-import fs4 from "fs";
+import fs3 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path5 from "path";
+import path4 from "path";
 function pluginDirFor(pkgJson) {
-  return path5.dirname(pkgJson);
+  return path4.dirname(pkgJson);
 }
 function duckdbPkgJsonFor(pluginDir) {
-  return path5.join(pluginDir, "node_modules", "@duckdb", "node-api", "package.json");
+  return path4.join(pluginDir, "node_modules", "@duckdb", "node-api", "package.json");
 }
 function loadDuckdb(opts = {}) {
   const pkgJson = opts.pluginPkgJson ?? PLUGIN_PKG_JSON;
   const pluginDir = pluginDirFor(pkgJson);
   const duckdbPkg = duckdbPkgJsonFor(pluginDir);
-  if (!fs4.existsSync(duckdbPkg)) {
+  if (!fs3.existsSync(duckdbPkg)) {
     throw missingDependency(
       "@duckdb/node-api is not installed. Run `canonry backlinks install` to enable the backlinks feature.",
       { pluginDir }
@@ -11256,12 +10037,12 @@ function loadDuckdb(opts = {}) {
 }
 function isDuckdbInstalled(opts = {}) {
   const pkgJson = opts.pluginPkgJson ?? PLUGIN_PKG_JSON;
-  return fs4.existsSync(duckdbPkgJsonFor(pluginDirFor(pkgJson)));
+  return fs3.existsSync(duckdbPkgJsonFor(pluginDirFor(pkgJson)));
 }
 function readInstalledVersion(opts = {}) {
   const pluginDir = opts.pluginPkgJson ? pluginDirFor(opts.pluginPkgJson) : PLUGIN_DIR;
   try {
-    const raw = fs4.readFileSync(duckdbPkgJsonFor(pluginDir), "utf8");
+    const raw = fs3.readFileSync(duckdbPkgJsonFor(pluginDir), "utf8");
     const pkg = JSON.parse(raw);
     return pkg.version ?? null;
   } catch {
@@ -11271,11 +10052,11 @@ function readInstalledVersion(opts = {}) {
 
 // ../integration-commoncrawl/src/plugin-installer.ts
 import { spawn } from "child_process";
-import fs5 from "fs/promises";
-import path6 from "path";
+import fs4 from "fs/promises";
+import path5 from "path";
 async function installDuckdb(opts = {}) {
   const pluginDir = opts.pluginDir ?? PLUGIN_DIR;
-  const pluginPkgJson = path6.join(pluginDir, "package.json");
+  const pluginPkgJson = path5.join(pluginDir, "package.json");
   const spec = opts.spec ?? DUCKDB_SPEC;
   const pkgManager = opts.packageManager ?? "npm";
   await ensurePluginDir(pluginDir, pluginPkgJson);
@@ -11291,12 +10072,12 @@ async function installDuckdb(opts = {}) {
   return { alreadyPresent: false, version, path: pluginDir };
 }
 async function ensurePluginDir(pluginDir = PLUGIN_DIR, pluginPkgJson = PLUGIN_PKG_JSON) {
-  await fs5.mkdir(pluginDir, { recursive: true });
+  await fs4.mkdir(pluginDir, { recursive: true });
   try {
-    await fs5.access(pluginPkgJson);
+    await fs4.access(pluginPkgJson);
   } catch {
     const contents = JSON.stringify({ name: "canonry-plugins", private: true, dependencies: {} }, null, 2);
-    await fs5.writeFile(pluginPkgJson, `${contents}
+    await fs4.writeFile(pluginPkgJson, `${contents}
 `);
   }
 }
@@ -11389,8 +10170,8 @@ function quote(s) {
 }
 
 // ../integration-commoncrawl/src/cache.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs5 from "fs";
+import path6 from "path";
 function cacheRoot(opts = {}) {
   return opts.cacheDir ?? CC_CACHE_DIR;
 }
@@ -11400,18 +10181,18 @@ function directoryBytesAndLastUsed(dir) {
   const walk = (p) => {
     let stat;
     try {
-      stat = fs6.statSync(p);
+      stat = fs5.statSync(p);
     } catch {
       return;
     }
     if (stat.isDirectory()) {
       let entries;
       try {
-        entries = fs6.readdirSync(p);
+        entries = fs5.readdirSync(p);
       } catch {
         return;
       }
-      for (const e of entries) walk(path7.join(p, e));
+      for (const e of entries) walk(path6.join(p, e));
     } else if (stat.isFile()) {
       bytes += stat.size;
       const mtime = Math.max(stat.mtimeMs, stat.atimeMs);
@@ -11426,13 +10207,13 @@ function directoryBytesAndLastUsed(dir) {
 }
 function listCachedReleases(opts = {}) {
   const root = cacheRoot(opts);
-  if (!fs6.existsSync(root)) return [];
-  const entries = fs6.readdirSync(root, { withFileTypes: true });
+  if (!fs5.existsSync(root)) return [];
+  const entries = fs5.readdirSync(root, { withFileTypes: true });
   const result = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (!RELEASE_ID_REGEX.test(entry.name)) continue;
-    const dir = path7.join(root, entry.name);
+    const dir = path6.join(root, entry.name);
     const stats = directoryBytesAndLastUsed(dir);
     result.push({ release: entry.name, bytes: stats.bytes, lastUsedAt: stats.lastUsedAt });
   }
@@ -11443,8 +10224,8 @@ function pruneCachedRelease(release, opts = {}) {
   if (!RELEASE_ID_REGEX.test(release)) {
     throw new Error(`Invalid release id: ${release}`);
   }
-  const dir = path7.join(cacheRoot(opts), release);
-  fs6.rmSync(dir, { recursive: true, force: true });
+  const dir = path6.join(cacheRoot(opts), release);
+  fs5.rmSync(dir, { recursive: true, force: true });
 }
 
 // ../api-routes/src/backlinks.ts
@@ -11787,7 +10568,7 @@ async function apiRoutes(app, opts) {
 }
 
 // src/server.ts
-import os6 from "os";
+import os5 from "os";
 
 // ../provider-gemini/src/normalize.ts
 import { GoogleGenAI } from "@google/genai";
@@ -13175,8 +11956,8 @@ var localAdapter = {
 };
 
 // ../provider-cdp/src/adapter.ts
-import path9 from "path";
-import os4 from "os";
+import path8 from "path";
+import os3 from "os";
 
 // ../provider-cdp/src/connection.ts
 import CDP from "chrome-remote-interface";
@@ -13540,12 +12321,12 @@ function sleep2(ms) {
 }
 
 // ../provider-cdp/src/screenshot.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs6 from "fs";
+import path7 from "path";
 async function captureElementScreenshot(client, selector, outputPath) {
-  const dir = path8.dirname(outputPath);
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(outputPath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   let clip;
   try {
@@ -13579,7 +12360,7 @@ async function captureElementScreenshot(client, selector, outputPath) {
   }
   const { data } = await client.Page.captureScreenshot(screenshotParams);
   const buffer = Buffer.from(data, "base64");
-  fs7.writeFileSync(outputPath, buffer);
+  fs6.writeFileSync(outputPath, buffer);
   return outputPath;
 }
 
@@ -13640,7 +12421,7 @@ function getConnection(config) {
   return conn;
 }
 function getScreenshotDir2() {
-  return path9.join(os4.homedir(), ".canonry", "screenshots");
+  return path8.join(os3.homedir(), ".canonry", "screenshots");
 }
 var cdpChatgptAdapter = {
   name: "cdp:chatgpt",
@@ -13704,7 +12485,7 @@ var cdpChatgptAdapter = {
       const answerText = await target.extractAnswer(client);
       const groundingSources = await target.extractCitations(client);
       const screenshotId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      const screenshotPath = path9.join(getScreenshotDir2(), `${screenshotId}.png`);
+      const screenshotPath = path8.join(getScreenshotDir2(), `${screenshotId}.png`);
       let capturedScreenshotPath;
       try {
         capturedScreenshotPath = await captureElementScreenshot(
@@ -14241,9 +13022,9 @@ function removeWordpressConnection(config, projectName) {
 
 // src/job-runner.ts
 import crypto19 from "crypto";
-import fs8 from "fs";
-import path10 from "path";
-import os5 from "os";
+import fs7 from "fs";
+import path9 from "path";
+import os4 from "os";
 import { and as and8, eq as eq19, inArray as inArray3, sql as sql6 } from "drizzle-orm";
 
 // src/citation-utils.ts
@@ -14627,12 +13408,12 @@ var JobRunner = class {
               competitorDomains
             );
             let screenshotRelPath = null;
-            if (raw.screenshotPath && fs8.existsSync(raw.screenshotPath)) {
+            if (raw.screenshotPath && fs7.existsSync(raw.screenshotPath)) {
               const snapshotId = crypto19.randomUUID();
-              const screenshotDir = path10.join(os5.homedir(), ".canonry", "screenshots", runId);
-              if (!fs8.existsSync(screenshotDir)) fs8.mkdirSync(screenshotDir, { recursive: true });
-              const destPath = path10.join(screenshotDir, `${snapshotId}.png`);
-              fs8.renameSync(raw.screenshotPath, destPath);
+              const screenshotDir = path9.join(os4.homedir(), ".canonry", "screenshots", runId);
+              if (!fs7.existsSync(screenshotDir)) fs7.mkdirSync(screenshotDir, { recursive: true });
+              const destPath = path9.join(screenshotDir, `${snapshotId}.png`);
+              fs7.renameSync(raw.screenshotPath, destPath);
               screenshotRelPath = `${runId}/${snapshotId}.png`;
               this.db.insert(querySnapshots).values({
                 id: snapshotId,
@@ -15421,7 +14202,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
 
 // src/commoncrawl-sync.ts
 import crypto23 from "crypto";
-import path11 from "path";
+import path10 from "path";
 import { and as and11, eq as eq23, sql as sql8 } from "drizzle-orm";
 var log6 = createLogger("CommonCrawlSync");
 var INSERT_CHUNK_SIZE = 1e4;
@@ -15450,9 +14231,9 @@ async function executeReleaseSync(db, syncId, opts) {
       error: null
     }).where(eq23(ccReleaseSyncs.id, syncId)).run();
     const paths = ccReleasePaths(release);
-    const releaseCacheDir = path11.join(deps.cacheDir, release);
-    const vertexPath = path11.join(releaseCacheDir, paths.vertexFilename);
-    const edgesPath = path11.join(releaseCacheDir, paths.edgesFilename);
+    const releaseCacheDir = path10.join(deps.cacheDir, release);
+    const vertexPath = path10.join(releaseCacheDir, paths.vertexFilename);
+    const edgesPath = path10.join(releaseCacheDir, paths.edgesFilename);
     const [vertex, edges] = await Promise.all([
       deps.downloadFile({ url: paths.vertexUrl, destPath: vertexPath }),
       deps.downloadFile({ url: paths.edgesUrl, destPath: edgesPath })
@@ -15612,7 +14393,7 @@ function computeSummary(rows) {
 
 // src/backlink-extract.ts
 import crypto24 from "crypto";
-import fs9 from "fs";
+import fs8 from "fs";
 import { and as and12, desc as desc10, eq as eq24 } from "drizzle-orm";
 var log7 = createLogger("BacklinkExtract");
 function defaultDeps2() {
@@ -15641,7 +14422,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     if (!sync.vertexPath || !sync.edgesPath) {
       throw new Error(`Release ${sync.release} is missing cached file paths`);
     }
-    if (!fs9.existsSync(sync.vertexPath) || !fs9.existsSync(sync.edgesPath)) {
+    if (!fs8.existsSync(sync.vertexPath) || !fs8.existsSync(sync.edgesPath)) {
       throw new Error(
         `Cache for release ${sync.release} is missing from disk (expected at ${sync.vertexPath}). The sync record exists in the database, but the ~16 GB dump was deleted or never present on this machine. Re-sync this release from the Backlinks admin page to restore the cache.`
       );
@@ -16160,8 +14941,8 @@ import crypto27 from "crypto";
 import { eq as eq28 } from "drizzle-orm";
 
 // src/agent/session.ts
-import fs12 from "fs";
-import path14 from "path";
+import fs11 from "fs";
+import path13 from "path";
 import { Agent } from "@mariozechner/pi-agent-core";
 import { registerBuiltInApiProviders } from "@mariozechner/pi-ai";
 
@@ -16262,26 +15043,26 @@ function buildAgentProvidersResponse(config) {
 }
 
 // src/agent/skill-paths.ts
-import fs10 from "fs";
-import path12 from "path";
+import fs9 from "fs";
+import path11 from "path";
 import { fileURLToPath } from "url";
 function resolveAeroSkillDir(pkgDir) {
-  const here = pkgDir ?? path12.dirname(fileURLToPath(import.meta.url));
+  const here = pkgDir ?? path11.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path12.join(here, "../assets/agent-workspace/skills/aero"),
-    path12.join(here, "../../assets/agent-workspace/skills/aero"),
-    path12.join(here, "../../../../skills/aero")
+    path11.join(here, "../assets/agent-workspace/skills/aero"),
+    path11.join(here, "../../assets/agent-workspace/skills/aero"),
+    path11.join(here, "../../../../skills/aero")
   ];
   for (const candidate of candidates) {
-    if (fs10.existsSync(path12.join(candidate, "SKILL.md"))) return candidate;
+    if (fs9.existsSync(path11.join(candidate, "SKILL.md"))) return candidate;
   }
   throw new Error(`Aero skill not found. Searched:
   ${candidates.join("\n  ")}`);
 }
 
 // src/agent/skill-tools.ts
-import fs11 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path12 from "path";
 import { Type } from "@sinclair/typebox";
 var MAX_DOC_CHARS = 2e4;
 function textResult(details) {
@@ -16302,13 +15083,13 @@ function parseDescription(body) {
   return "(no description)";
 }
 function scanSkillDocs(skillDir) {
-  const refsDir = path13.join(skillDir ?? resolveAeroSkillDir(), "references");
-  if (!fs11.existsSync(refsDir)) return [];
+  const refsDir = path12.join(skillDir ?? resolveAeroSkillDir(), "references");
+  if (!fs10.existsSync(refsDir)) return [];
   const entries = [];
-  for (const file of fs11.readdirSync(refsDir)) {
+  for (const file of fs10.readdirSync(refsDir)) {
     if (!file.endsWith(".md")) continue;
-    const filePath = path13.join(refsDir, file);
-    const body = fs11.readFileSync(filePath, "utf-8");
+    const filePath = path12.join(refsDir, file);
+    const body = fs10.readFileSync(filePath, "utf-8");
     entries.push({
       slug: file.replace(/\.md$/, ""),
       description: parseDescription(body),
@@ -16351,8 +15132,8 @@ function buildReadSkillDocTool() {
           availableSlugs: docs.map((d) => d.slug)
         });
       }
-      const filePath = path13.join(skillDir, "references", `${match.slug}.md`);
-      const content = fs11.readFileSync(filePath, "utf-8");
+      const filePath = path12.join(skillDir, "references", `${match.slug}.md`);
+      const content = fs10.readFileSync(filePath, "utf-8");
       if (content.length > MAX_DOC_CHARS) {
         return textResult({
           slug: match.slug,
@@ -16747,7 +15528,7 @@ function buildAddCompetitorsTool(ctx) {
   return {
     name: "add_competitors",
     label: "Add competitors",
-    description: "Append competitor domains to the project. Fetches the current set, merges with the requested domains (dedup on exact domain match), and persists the combined list.",
+    description: "Append competitor domains to the project. Existing competitors are skipped by the API.",
     parameters: AddCompetitorsSchema,
     execute: async (_toolCallId, params) => {
       const existing = await ctx.client.listCompetitors(ctx.projectName);
@@ -16756,8 +15537,7 @@ function buildAddCompetitorsTool(ctx) {
       if (newDomains.length === 0) {
         return textResult2({ added: [], alreadyTracked: params.domains });
       }
-      const merged = [...existing.map((c) => c.domain), ...newDomains];
-      await ctx.client.putCompetitors(ctx.projectName, merged);
+      await ctx.client.appendCompetitors(ctx.projectName, newDomains);
       return textResult2({ added: newDomains, alreadyTracked: params.domains.filter((d) => existingDomains.has(d)) });
     }
   };
@@ -16906,10 +15686,10 @@ function ensureBuiltinsRegistered() {
 }
 function loadAeroSystemPrompt(pkgDir) {
   const skillDir = resolveAeroSkillDir(pkgDir);
-  const skillBody = fs12.readFileSync(path14.join(skillDir, "SKILL.md"), "utf-8");
-  const soulPath = path14.join(skillDir, "soul.md");
-  if (!fs12.existsSync(soulPath)) return skillBody;
-  const soulBody = fs12.readFileSync(soulPath, "utf-8");
+  const skillBody = fs11.readFileSync(path13.join(skillDir, "SKILL.md"), "utf-8");
+  const soulPath = path13.join(skillDir, "soul.md");
+  if (!fs11.existsSync(soulPath)) return skillBody;
+  const soulBody = fs11.readFileSync(soulPath, "utf-8");
   return `${soulBody.trimEnd()}
 
 ---
@@ -17698,593 +16478,6 @@ function registerAgentRoutes(app, opts) {
   );
 }
 
-// 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, path16, body) {
-    await this.probeBasePath();
-    const url = `${this.baseUrl}${path16}`;
-    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: { 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(path16, body, signal) {
-    await this.probeBasePath();
-    const url = `${this.baseUrl}${path16}`;
-    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, keywords2) {
-    await this.request("PUT", `/projects/${encodeURIComponent(project)}/keywords`, { keywords: keywords2 });
-  }
-  async listKeywords(project) {
-    return this.request("GET", `/projects/${encodeURIComponent(project)}/keywords`);
-  }
-  async deleteKeywords(project, keywords2) {
-    await this.request("DELETE", `/projects/${encodeURIComponent(project)}/keywords`, { keywords: keywords2 });
-  }
-  async appendKeywords(project, keywords2) {
-    await this.request("POST", `/projects/${encodeURIComponent(project)}/keywords`, { keywords: keywords2 });
-  }
-  async putCompetitors(project, competitors2) {
-    await this.request("PUT", `/projects/${encodeURIComponent(project)}/competitors`, { competitors: competitors2 });
-  }
-  async listCompetitors(project) {
-    return this.request("GET", `/projects/${encodeURIComponent(project)}/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) {
-    return this.request("GET", `/projects/${encodeURIComponent(project)}/timeline`);
-  }
-  async getHistory(project) {
-    return this.request("GET", `/projects/${encodeURIComponent(project)}/history`);
-  }
-  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 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`);
-  }
-};
-
 // src/snapshot-service.ts
 import { runAeoAudit } from "@ainyc/aeo-audit";
 
@@ -18307,13 +16500,13 @@ function extractHostname(domain) {
 function fetchWithPinnedAddress(target) {
   return new Promise((resolve) => {
     const port = target.url.port ? Number(target.url.port) : 443;
-    const path16 = target.url.pathname + target.url.search;
+    const path15 = target.url.pathname + target.url.search;
     const req = https2.request(
       {
         hostname: target.address,
         family: target.family,
         port,
-        path: path16,
+        path: path15,
         method: "GET",
         timeout: FETCH_TIMEOUT_MS,
         servername: target.url.hostname,
@@ -18520,7 +16713,7 @@ var SnapshotService = class {
     });
     const enrichedResults = applyBatchAssessment(queryResults, batchAssessment);
     const summary = buildSnapshotSummary(companyName, profile.phrases, providers, enrichedResults, audit, batchAssessment);
-    const reportCompetitors = uniqueStrings([
+    const reportCompetitors = uniqueStrings2([
       ...manualCompetitors,
       ...summary.topCompetitors.map((entry) => entry.name)
     ]);
@@ -18573,8 +16766,8 @@ var SnapshotService = class {
         return {
           industry: parsed.industry?.trim() || "Unknown",
           summary: parsed.summary?.trim() || ctx.audit.summary,
-          services: uniqueStrings(parsed.services ?? []).slice(0, 6),
-          categoryTerms: uniqueStrings(parsed.categoryTerms ?? []).slice(0, 8),
+          services: uniqueStrings2(parsed.services ?? []).slice(0, 6),
+          categoryTerms: uniqueStrings2(parsed.categoryTerms ?? []).slice(0, 8),
           phrases: parsedPhrases
         };
       } catch (err) {
@@ -18642,9 +16835,9 @@ var SnapshotService = class {
               accuracyNotes: null,
               incorrectClaims: [],
               recommendedCompetitors: preliminaryCompetitors,
-              citedDomains: uniqueStrings(normalized.citedDomains),
+              citedDomains: uniqueStrings2(normalized.citedDomains),
               groundingSources: normalized.groundingSources,
-              searchQueries: uniqueStrings(normalized.searchQueries),
+              searchQueries: uniqueStrings2(normalized.searchQueries),
               answerText: normalized.answerText,
               error: null
             };
@@ -18710,14 +16903,14 @@ var SnapshotService = class {
             mentioned: assessment.mentioned,
             describedAccurately: assessment.describedAccurately,
             accuracyNotes: assessment.accuracyNotes ?? null,
-            incorrectClaims: uniqueStrings(assessment.incorrectClaims ?? []).slice(0, 5),
+            incorrectClaims: uniqueStrings2(assessment.incorrectClaims ?? []).slice(0, 5),
             ...hasReviewedCompetitors ? {
-              recommendedCompetitors: uniqueStrings(assessment.recommendedCompetitors ?? []).slice(0, 10)
+              recommendedCompetitors: uniqueStrings2(assessment.recommendedCompetitors ?? []).slice(0, 10)
             } : {}
           };
         }),
-        whatThisMeans: uniqueStrings(parsed.whatThisMeans ?? []).slice(0, 4),
-        recommendedActions: uniqueStrings(parsed.recommendedActions ?? []).slice(0, 4)
+        whatThisMeans: uniqueStrings2(parsed.whatThisMeans ?? []).slice(0, 4),
+        recommendedActions: uniqueStrings2(parsed.recommendedActions ?? []).slice(0, 4)
       };
     } catch (err) {
       log12.warn("response.analysis-failed", {
@@ -18812,13 +17005,13 @@ function applyBatchAssessment(queryResults, batchAssessment) {
         };
       }
       const reviewedCompetitors = assessment.recommendedCompetitors;
-      const recommendedCompetitors = reviewedCompetitors !== void 0 ? uniqueStrings(reviewedCompetitors) : result.recommendedCompetitors;
+      const recommendedCompetitors = reviewedCompetitors !== void 0 ? uniqueStrings2(reviewedCompetitors) : result.recommendedCompetitors;
       return {
         ...result,
         mentioned: result.mentioned || assessment.mentioned === true,
         describedAccurately: assessment.describedAccurately ?? (result.mentioned ? "unknown" : "not-mentioned"),
         accuracyNotes: assessment.accuracyNotes ?? result.accuracyNotes ?? null,
-        incorrectClaims: uniqueStrings([
+        incorrectClaims: uniqueStrings2([
           ...result.incorrectClaims,
           ...assessment.incorrectClaims ?? []
         ]),
@@ -18848,7 +17041,7 @@ function buildSnapshotSummary(companyName, phrases, providers, queryResults, aud
   const whatThisMeans = batchAssessment.whatThisMeans.length > 0 ? batchAssessment.whatThisMeans : [
     defaultMeaning
   ];
-  const combinedWhatThisMeans = uniqueStrings([...whatThisMeans, ...failureNote]).slice(0, 5);
+  const combinedWhatThisMeans = uniqueStrings2([...whatThisMeans, ...failureNote]).slice(0, 5);
   const recommendedActions = batchAssessment.recommendedActions.length > 0 ? batchAssessment.recommendedActions : buildFallbackRecommendedActions(audit);
   return {
     totalQueries: phrases.length,
@@ -18891,7 +17084,7 @@ function buildFallbackRecommendedActions(audit) {
     "Add machine-readable trust signals such as schema, FAQs, and llms.txt support.",
     "Build comparison and proof content that makes the category fit unmistakable."
   ];
-  return uniqueStrings([...weakestFactors, ...defaults]).slice(0, 4);
+  return uniqueStrings2([...weakestFactors, ...defaults]).slice(0, 4);
 }
 function citesTargetDomain(citedDomains, groundingSources, targetDomain) {
   const normalizedTarget = extractHostname2(targetDomain);
@@ -18965,11 +17158,11 @@ function parseJsonObject(input) {
 }
 function normalizeStringList(values) {
   const items = values.flatMap((value) => value.split(","));
-  return uniqueStrings(
+  return uniqueStrings2(
     items.map((value) => value.trim()).filter(Boolean)
   );
 }
-function uniqueStrings(values) {
+function uniqueStrings2(values) {
   if (!Array.isArray(values)) return [];
   return [...new Set(
     values.filter((value) => typeof value === "string").map((value) => value.trim()).filter(Boolean)
@@ -19206,8 +17399,8 @@ async function createServer(opts) {
   );
   jobRunner.onRunCompleted = (runId, projectId) => runCoordinator.onRunCompleted(runId, projectId);
   const snapshotService = new SnapshotService(registry);
-  const orphanedOpenClawDir = path15.join(os6.homedir(), ".openclaw-aero");
-  if (fs13.existsSync(orphanedOpenClawDir)) {
+  const orphanedOpenClawDir = path14.join(os5.homedir(), ".openclaw-aero");
+  if (fs12.existsSync(orphanedOpenClawDir)) {
     app.log.warn(
       { path: orphanedOpenClawDir },
       "OpenClaw gateway is no longer used. Remove ~/.openclaw-aero/ manually to reclaim the directory."
@@ -19801,10 +17994,10 @@ async function createServer(opts) {
       return snapshotService.createReport(input);
     }
   });
-  const dirname = path15.dirname(fileURLToPath2(import.meta.url));
-  const assetsDir = path15.join(dirname, "..", "assets");
-  if (fs13.existsSync(assetsDir)) {
-    const indexPath = path15.join(assetsDir, "index.html");
+  const dirname = path14.dirname(fileURLToPath2(import.meta.url));
+  const assetsDir = path14.join(dirname, "..", "assets");
+  if (fs12.existsSync(assetsDir)) {
+    const indexPath = path14.join(assetsDir, "index.html");
     const injectConfig = (html) => {
       const clientConfig = {};
       if (basePath) clientConfig.basePath = basePath;
@@ -19822,8 +18015,8 @@ async function createServer(opts) {
       index: false
     });
     const serveIndex = (_request, reply) => {
-      if (fs13.existsSync(indexPath)) {
-        const html = fs13.readFileSync(indexPath, "utf-8");
+      if (fs12.existsSync(indexPath)) {
+        const html = fs12.readFileSync(indexPath, "utf-8");
         return reply.type("text/html").send(injectConfig(html));
       }
       return reply.status(404).send({ error: "Dashboard not built" });
@@ -19843,8 +18036,8 @@ async function createServer(opts) {
       if (basePath && !url.startsWith(basePath)) {
         return reply.status(404).send({ error: "Not found", path: request.url });
       }
-      if (fs13.existsSync(indexPath)) {
-        const html = fs13.readFileSync(indexPath, "utf-8");
+      if (fs12.existsSync(indexPath)) {
+        const html = fs12.readFileSync(indexPath, "utf-8");
         return reply.type("text/html").send(injectConfig(html));
       }
       return reply.status(404).send({ error: "Not found" });
@@ -19913,31 +18106,11 @@ function parseKeywordResponse(raw, count) {
 }
 
 export {
-  getConfigDir,
-  getConfigPath,
-  loadConfig,
-  saveConfig,
-  saveConfigPatch,
-  configExists,
   isTelemetryEnabled,
   getOrCreateAnonymousId,
   isFirstRun,
   showFirstRunNotice,
   trackEvent,
-  EXIT_SYSTEM_ERROR,
-  CliError,
-  usageError,
-  isEndpointMissing,
-  printCliError,
-  providerQuotaPolicySchema,
-  ProviderNames,
-  resolveProviderInput,
-  notificationEventSchema,
-  effectiveDomains,
-  RunStatuses,
-  RunKinds,
-  determineAnswerMentioned,
-  CcReleaseSyncStatuses,
   reparseStoredResult2 as reparseStoredResult,
   reparseStoredResult3 as reparseStoredResult2,
   reparseStoredResult as reparseStoredResult3,
@@ -19945,7 +18118,6 @@ export {
   determineCitationState,
   computeCompetitorOverlap,
   extractRecommendedCompetitors,
-  createApiClient,
   setGoogleAuthConfig,
   formatAuditFactorScore,
   listAgentProviders,