@ainyc/canonry 2.5.0 → 2.6.0

package/dist/{chunk-TIHU2YXW.js → chunk-LF4O276A.js}

@@ -1,3 +1,55 @@
+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,
+  configExists,
+  deliveryFailed,
+  determineAnswerMentioned,
+  effectiveDomains,
+  extractAnswerMentions,
+  findDuplicateLocationLabels,
+  hasLocationLabel,
+  internalError,
+  isAgentProviderId,
+  isBrowserProvider,
+  loadConfig,
+  locationContextSchema,
+  missingDependency,
+  normalizeProjectDomain,
+  notFound,
+  notImplemented,
+  parseWindow,
+  projectConfigSchema,
+  projectUpsertRequestSchema,
+  providerError,
+  runInProgress,
+  runNotCancellable,
+  runTriggerRequestSchema,
+  saveConfigPatch,
+  scheduleUpsertRequestSchema,
+  snapshotRequestSchema,
+  unsupportedKind,
+  validationError,
+  visibilityStateFromAnswerMentioned,
+  windowCutoff,
+  wordpressEnvSchema
+} from "./chunk-3DUTT6H2.js";
 import {
   IntelligenceService,
   agentMemory,
@@ -30,172 +82,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 +156,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";
@@ -2132,11 +775,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 +797,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 +813,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 +982,11 @@ 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 });
+}
 function formatRun(row) {
   return {
     id: row.id,
@@ -2550,7 +1198,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 +1214,7 @@ async function deliverWebhook(target, payload, webhookSecret) {
       headers,
       hostname: target.address,
       method: "POST",
-      path: path16,
+      path: path15,
       port,
       timeout: REQUEST_TIMEOUT_MS
     };
@@ -3604,7 +2252,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 +2304,7 @@ var googleTypeParameter = {
   in: "path",
   required: true,
   description: "Google connection type.",
-  schema: googleConnectionTypeSchema2
+  schema: googleConnectionTypeSchema
 };
 var projectRunIdParameter = {
   name: "runId",
@@ -4649,7 +3297,7 @@ var routeCatalog = [
             type: "object",
             required: ["type"],
             properties: {
-              type: googleConnectionTypeSchema2,
+              type: googleConnectionTypeSchema,
               propertyId: stringSchema,
               publicUrl: stringSchema
             }
@@ -6071,8 +4719,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 +5242,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 +5252,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 +5280,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 +5594,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 +6730,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 +6758,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 +7302,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 +7317,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 +8332,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 +8850,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 +8962,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 +9756,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 +9792,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 +9801,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 +9809,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 +9832,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 +9849,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 +9857,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 +9873,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 +9904,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 +9919,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 +9939,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 +10037,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 +10048,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 +10074,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 +10091,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 +10435,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 +11823,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 +12188,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 +12227,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 +12288,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 +12352,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 +12889,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 +13275,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,
@@ -14998,6 +13646,7 @@ import crypto21 from "crypto";
 import { eq as eq21, and as and10 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
+var log3 = createLogger("SitemapParser");
 var LOC_REGEX = /<loc>\s*([^<]+?)\s*<\/loc>/gi;
 var SITEMAP_TAG_REGEX = /<sitemap>[\s\S]*?<\/sitemap>/gi;
 var PRIVATE_IP_PATTERNS = [
@@ -15027,26 +13676,77 @@ function validateSitemapUrl(url) {
     }
   }
 }
+async function readSitemapBody(res) {
+  const buf = await res.arrayBuffer();
+  const bytes = new Uint8Array(buf);
+  const isGzipped = bytes.length >= 2 && bytes[0] === 31 && bytes[1] === 139;
+  if (!isGzipped) {
+    return new TextDecoder().decode(bytes);
+  }
+  const decompressed = new Blob([buf]).stream().pipeThrough(new DecompressionStream("gzip"));
+  return new Response(decompressed).text();
+}
 async function fetchAndParseSitemap(sitemapUrl) {
   const urls = /* @__PURE__ */ new Set();
-  await parseSitemapRecursive(sitemapUrl, urls, 0);
+  const visited = /* @__PURE__ */ new Set();
+  await parseSitemapRecursive(
+    sitemapUrl,
+    urls,
+    visited,
+    0,
+    /* isChild */
+    false
+  );
   return [...urls];
 }
-async function parseSitemapRecursive(url, urls, depth) {
+async function parseSitemapRecursive(url, urls, visited, depth, isChild) {
   if (depth > 3) return;
+  if (visited.has(url)) return;
+  visited.add(url);
   validateSitemapUrl(url);
-  const res = await fetch(url);
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    if (!isChild) throw err;
+    log3.warn("child-sitemap.fetch-failed", {
+      url,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
   if (!res.ok) {
-    throw new Error(`Failed to fetch sitemap at ${url}: ${res.status} ${res.statusText}`);
+    if (!isChild) {
+      throw new Error(`Failed to fetch sitemap at ${url}: ${res.status} ${res.statusText}`);
+    }
+    log3.warn("child-sitemap.http-error", { url, status: res.status, statusText: res.statusText });
+    return;
+  }
+  let xml;
+  try {
+    xml = await readSitemapBody(res);
+  } catch (err) {
+    if (!isChild) throw err;
+    log3.warn("child-sitemap.parse-failed", {
+      url,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return;
   }
-  const xml = await res.text();
   const sitemapEntries = xml.match(SITEMAP_TAG_REGEX);
   if (sitemapEntries) {
     for (const entry of sitemapEntries) {
       const locMatch = LOC_REGEX.exec(entry);
       LOC_REGEX.lastIndex = 0;
       if (locMatch?.[1]) {
-        await parseSitemapRecursive(locMatch[1], urls, depth + 1);
+        await parseSitemapRecursive(
+          locMatch[1],
+          urls,
+          visited,
+          depth + 1,
+          /* isChild */
+          true
+        );
       }
     }
     return;
@@ -15061,7 +13761,7 @@ async function parseSitemapRecursive(url, urls, depth) {
 }
 
 // src/gsc-inspect-sitemap.ts
-var log3 = createLogger("InspectSitemap");
+var log4 = createLogger("InspectSitemap");
 async function executeInspectSitemap(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.update(runs).set({ status: "running", startedAt: now }).where(eq21(runs.id, runId)).run();
@@ -15094,9 +13794,9 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       saveConfigPatch(opts.config);
     }
     const sitemapUrl = opts.sitemapUrl || conn.sitemapUrl || `https://${project.canonicalDomain}/sitemap.xml`;
-    log3.info("sitemap.fetch", { runId, projectId, sitemapUrl });
+    log4.info("sitemap.fetch", { runId, projectId, sitemapUrl });
     const urls = await fetchAndParseSitemap(sitemapUrl);
-    log3.info("sitemap.parsed", { runId, projectId, urlCount: urls.length, sitemapUrl });
+    log4.info("sitemap.parsed", { runId, projectId, urlCount: urls.length, sitemapUrl });
     if (urls.length === 0) {
       throw new Error("No URLs found in sitemap");
     }
@@ -15129,10 +13829,10 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
           createdAt: inspectedAt
         }).run();
         inspected++;
-        log3.info("inspect.url-done", { runId, projectId, url: pageUrl, progress: `${inspected}/${urls.length}` });
+        log4.info("inspect.url-done", { runId, projectId, url: pageUrl, progress: `${inspected}/${urls.length}` });
       } catch (err) {
         errors++;
-        log3.error("inspect.url-failed", { runId, projectId, url: pageUrl, error: err instanceof Error ? err.message : String(err) });
+        log4.error("inspect.url-failed", { runId, projectId, url: pageUrl, error: err instanceof Error ? err.message : String(err) });
       }
       if (inspected + errors < urls.length) {
         await new Promise((r) => setTimeout(r, 1e3));
@@ -15172,11 +13872,11 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
     }).run();
     const status = errors > 0 && inspected > 0 ? "partial" : errors === urls.length ? "failed" : "completed";
     db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(runs.id, runId)).run();
-    log3.info("inspect.completed", { runId, projectId, inspected, errors, total: urls.length, indexed: snapIndexed, notIndexed: snapNotIndexed });
+    log4.info("inspect.completed", { runId, projectId, inspected, errors, total: urls.length, indexed: snapIndexed, notIndexed: snapNotIndexed });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq21(runs.id, runId)).run();
-    log3.error("inspect.failed", { runId, projectId, error: errorMsg });
+    log4.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
@@ -15184,7 +13884,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
 // src/bing-inspect-sitemap.ts
 import crypto22 from "crypto";
 import { eq as eq22, desc as desc9 } from "drizzle-orm";
-var log4 = createLogger("BingInspectSitemap");
+var log5 = createLogger("BingInspectSitemap");
 function parseBingDate2(value) {
   if (!value) return null;
   const match = /\/Date\((-?\d+)[^)]*\)\//.exec(value);
@@ -15215,16 +13915,16 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
       throw new Error('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
     }
     const sitemapUrl = opts.sitemapUrl ?? `https://${project.canonicalDomain}/sitemap.xml`;
-    log4.info("sitemap.fetch", { runId, projectId, sitemapUrl });
+    log5.info("sitemap.fetch", { runId, projectId, sitemapUrl });
     const sitemapUrls = await fetchAndParseSitemap(sitemapUrl);
-    log4.info("sitemap.parsed", { runId, projectId, urlCount: sitemapUrls.length, sitemapUrl });
+    log5.info("sitemap.parsed", { runId, projectId, urlCount: sitemapUrls.length, sitemapUrl });
     if (sitemapUrls.length === 0) {
       throw new Error("No URLs found in sitemap");
     }
     const trackedRows = db.select({ url: bingUrlInspections.url }).from(bingUrlInspections).where(eq22(bingUrlInspections.projectId, projectId)).all();
     const trackedUrls = new Set(trackedRows.map((r) => r.url));
     const discovered = sitemapUrls.filter((u) => !trackedUrls.has(u));
-    log4.info("sitemap.diff", {
+    log5.info("sitemap.diff", {
       runId,
       projectId,
       sitemapTotal: sitemapUrls.length,
@@ -15239,9 +13939,9 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
           blockedUrls.add(issue.Url);
         }
       }
-      log4.info("crawl-issues.loaded", { runId, projectId, blockedCount: blockedUrls.size });
+      log5.info("crawl-issues.loaded", { runId, projectId, blockedCount: blockedUrls.size });
     } catch (err) {
-      log4.warn("crawl-issues.lookup-failed", {
+      log5.warn("crawl-issues.lookup-failed", {
         runId,
         projectId,
         error: err instanceof Error ? err.message : String(err)
@@ -15285,7 +13985,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
           discoveryDate
         }).run();
         inspected++;
-        log4.info("inspect.url-done", {
+        log5.info("inspect.url-done", {
           runId,
           projectId,
           url: pageUrl,
@@ -15293,7 +13993,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
         });
       } catch (err) {
         errors++;
-        log4.error("inspect.url-failed", {
+        log5.error("inspect.url-failed", {
           runId,
           projectId,
           url: pageUrl,
@@ -15348,7 +14048,7 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
     }).run();
     const status = errors === sitemapUrls.length ? RunStatuses.failed : errors > 0 ? RunStatuses.partial : RunStatuses.completed;
     db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(runs.id, runId)).run();
-    log4.info("inspect.completed", {
+    log5.info("inspect.completed", {
       runId,
       projectId,
       inspected,
@@ -15362,16 +14062,16 @@ async function executeBingInspectSitemap(db, runId, projectId, opts) {
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     db.update(runs).set({ status: RunStatuses.failed, error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq22(runs.id, runId)).run();
-    log4.error("inspect.failed", { runId, projectId, error: errorMsg });
+    log5.error("inspect.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // 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 log5 = createLogger("CommonCrawlSync");
+var log6 = createLogger("CommonCrawlSync");
 var INSERT_CHUNK_SIZE = 1e4;
 function defaultDeps() {
   return {
@@ -15398,9 +14098,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 })
@@ -15496,7 +14196,7 @@ async function executeReleaseSync(db, syncId, opts) {
       updatedAt: finishedAt,
       error: null
     }).where(eq23(ccReleaseSyncs.id, syncId)).run();
-    log5.info("sync.completed", {
+    log6.info("sync.completed", {
       syncId,
       release,
       projectsProcessed: allProjects.length,
@@ -15508,7 +14208,7 @@ async function executeReleaseSync(db, syncId, opts) {
         try {
           deps.enqueueAutoExtract({ projectId: p.id, release });
         } catch (err) {
-          log5.error("auto-extract.enqueue-failed", {
+          log6.error("auto-extract.enqueue-failed", {
             syncId,
             release,
             projectId: p.id,
@@ -15526,7 +14226,7 @@ async function executeReleaseSync(db, syncId, opts) {
       phaseDetail: null,
       updatedAt: finishedAt
     }).where(eq23(ccReleaseSyncs.id, syncId)).run();
-    log5.error("sync.failed", { syncId, release, error: errorMsg });
+    log6.error("sync.failed", { syncId, release, error: errorMsg });
     throw err;
   }
 }
@@ -15560,9 +14260,9 @@ 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 log6 = createLogger("BacklinkExtract");
+var log7 = createLogger("BacklinkExtract");
 function defaultDeps2() {
   return {
     queryBacklinks,
@@ -15589,7 +14289,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.`
       );
@@ -15648,7 +14348,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     });
     const finishedAt = deps.now().toISOString();
     db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq24(runs.id, runId)).run();
-    log6.info("extract.completed", { runId, projectId, release, rows: rows.length });
+    log7.info("extract.completed", { runId, projectId, release, rows: rows.length });
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     const finishedAt = deps.now().toISOString();
@@ -15657,7 +14357,7 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
       error: errorMsg,
       finishedAt
     }).where(eq24(runs.id, runId)).run();
-    log6.error("extract.failed", { runId, projectId, error: errorMsg });
+    log7.error("extract.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
@@ -15730,7 +14430,7 @@ var ProviderRegistry = class {
 // src/scheduler.ts
 import cron from "node-cron";
 import { eq as eq25 } from "drizzle-orm";
-var log7 = createLogger("Scheduler");
+var log8 = createLogger("Scheduler");
 var Scheduler = class {
   db;
   callbacks;
@@ -15746,11 +14446,11 @@ var Scheduler = class {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
       if (missedRunAt && new Date(missedRunAt) < /* @__PURE__ */ new Date()) {
-        log7.info("run.catch-up", { projectId: schedule.projectId, missedRunAt });
+        log8.info("run.catch-up", { projectId: schedule.projectId, missedRunAt });
         this.triggerRun(schedule.id, schedule.projectId);
       }
     }
-    log7.info("started", { scheduleCount: allSchedules.length });
+    log8.info("started", { scheduleCount: allSchedules.length });
   }
   /** Stop all cron tasks for graceful shutdown. */
   stop() {
@@ -15782,12 +14482,12 @@ var Scheduler = class {
   stopTask(projectId, task, verb) {
     task.stop();
     task.destroy();
-    log7.info(`task.${verb.toLowerCase()}`, { projectId });
+    log8.info(`task.${verb.toLowerCase()}`, { projectId });
   }
   registerCronTask(schedule) {
     const { id: scheduleId, projectId, cronExpr, timezone } = schedule;
     if (!cron.validate(cronExpr)) {
-      log7.error("cron.invalid", { projectId, cronExpr });
+      log8.error("cron.invalid", { projectId, cronExpr });
       return;
     }
     const task = cron.schedule(cronExpr, () => {
@@ -15801,14 +14501,14 @@ var Scheduler = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     }).where(eq25(schedules.id, scheduleId)).run();
     const label = schedule.preset ?? cronExpr;
-    log7.info("cron.registered", { projectId, schedule: label, timezone });
+    log8.info("cron.registered", { projectId, schedule: label, timezone });
   }
   triggerRun(scheduleId, projectId) {
     try {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const currentSchedule = this.db.select().from(schedules).where(eq25(schedules.id, scheduleId)).get();
       if (!currentSchedule || currentSchedule.enabled !== 1) {
-        log7.warn("schedule.stale", { scheduleId, projectId, msg: "schedule no longer exists or is disabled" });
+        log8.warn("schedule.stale", { scheduleId, projectId, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId);
         return;
       }
@@ -15816,7 +14516,7 @@ var Scheduler = class {
       const nextRunAt = task?.getNextRun()?.toISOString() ?? null;
       const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
       if (!project) {
-        log7.error("project.not-found", { projectId, msg: "skipping scheduled run" });
+        log8.error("project.not-found", { projectId, msg: "skipping scheduled run" });
         this.remove(projectId);
         return;
       }
@@ -15825,7 +14525,7 @@ var Scheduler = class {
       if (project.defaultLocation) {
         const loc = projectLocations.find((l) => l.label === project.defaultLocation);
         if (!loc) {
-          log7.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
+          log8.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
           return;
         }
         resolvedLocation = loc;
@@ -15839,7 +14539,7 @@ var Scheduler = class {
         location: locationLabel
       });
       if (queueResult.conflict) {
-        log7.info("run.skipped-active", { projectName: project.name, activeRunId: queueResult.activeRunId });
+        log8.info("run.skipped-active", { projectName: project.name, activeRunId: queueResult.activeRunId });
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
@@ -15854,10 +14554,10 @@ var Scheduler = class {
       }).where(eq25(schedules.id, currentSchedule.id)).run();
       const scheduleProviders = parseJsonColumn(currentSchedule.providers, []);
       const providers = scheduleProviders.length > 0 ? scheduleProviders : void 0;
-      log7.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
+      log8.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
       this.callbacks.onRunCreated(runId, projectId, providers, resolvedLocation);
     } catch (err) {
-      log7.error("trigger.error", { scheduleId, projectId, error: err instanceof Error ? err.message : String(err) });
+      log8.error("trigger.error", { scheduleId, projectId, error: err instanceof Error ? err.message : String(err) });
     }
   }
 };
@@ -15865,7 +14565,7 @@ var Scheduler = class {
 // src/notifier.ts
 import { eq as eq26, desc as desc11, and as and13, or as or2 } from "drizzle-orm";
 import crypto25 from "crypto";
-var log8 = createLogger("Notifier");
+var log9 = createLogger("Notifier");
 var Notifier = class {
   db;
   serverUrl;
@@ -15875,26 +14575,26 @@ var Notifier = class {
   }
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
-    log8.info("run.completed", { runId, projectId });
+    log9.info("run.completed", { runId, projectId });
     const notifs = this.db.select().from(notifications).where(eq26(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
     if (notifs.length === 0) {
-      log8.info("notifications.none-enabled", { projectId });
+      log9.info("notifications.none-enabled", { projectId });
       return;
     }
-    log8.info("notifications.found", { projectId, count: notifs.length });
+    log9.info("notifications.found", { projectId, count: notifs.length });
     const run = this.db.select().from(runs).where(eq26(runs.id, runId)).get();
     if (!run) {
-      log8.error("run.not-found", { runId, msg: "skipping notification dispatch" });
+      log9.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
     const project = this.db.select().from(projects).where(eq26(projects.id, projectId)).get();
     if (!project) {
-      log8.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
+      log9.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
     }
     const transitions = this.computeTransitions(runId, projectId);
     const events = [];
-    log8.info("run.status", { runId: run.id, status: run.status, projectId });
+    log9.info("run.status", { runId: run.id, status: run.status, projectId });
     if (run.status === "completed" || run.status === "partial") {
       events.push("run.completed");
     }
@@ -15910,7 +14610,7 @@ var Notifier = class {
       if (!config.url) continue;
       const subscribedEvents = config.events;
       const matchingEvents = events.filter((e) => subscribedEvents.includes(e));
-      log8.info("notification.match", { notificationId: notif.id, subscribedEvents, matchedEvents: matchingEvents });
+      log9.info("notification.match", { notificationId: notif.id, subscribedEvents, matchedEvents: matchingEvents });
       if (matchingEvents.length === 0) continue;
       for (const event of matchingEvents) {
         const relevantTransitions = event === "citation.lost" ? lostTransitions : event === "citation.gained" ? gainedTransitions : transitions;
@@ -16012,23 +14712,23 @@ var Notifier = class {
     const targetLabel = redactNotificationUrl(url).urlDisplay;
     const targetCheck = await resolveWebhookTarget(url);
     if (!targetCheck.ok) {
-      log8.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
+      log9.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
       this.logDelivery(projectId, notificationId, payload.event, "failed", `SSRF: ${targetCheck.message}`);
       return;
     }
-    log8.info("webhook.send", { event: payload.event, url: targetLabel });
+    log9.info("webhook.send", { event: payload.event, url: targetLabel });
     const maxRetries = 3;
     const delays = [1e3, 4e3, 16e3];
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
         const response = await deliverWebhook(targetCheck.target, payload, webhookSecret);
         if (response.status >= 200 && response.status < 300) {
-          log8.info("webhook.delivered", { event: payload.event, url: targetLabel, httpStatus: response.status });
+          log9.info("webhook.delivered", { event: payload.event, url: targetLabel, httpStatus: response.status });
           this.logDelivery(projectId, notificationId, payload.event, "sent", null);
           return;
         }
         const errorDetail = response.error ?? `HTTP ${response.status}`;
-        log8.warn("webhook.attempt-failed", { event: payload.event, url: targetLabel, attempt: attempt + 1, maxRetries, httpStatus: response.status, error: errorDetail });
+        log9.warn("webhook.attempt-failed", { event: payload.event, url: targetLabel, attempt: attempt + 1, maxRetries, httpStatus: response.status, error: errorDetail });
         if (attempt === maxRetries - 1) {
           this.logDelivery(projectId, notificationId, payload.event, "failed", errorDetail);
         }
@@ -16036,7 +14736,7 @@ var Notifier = class {
         const errorDetail = err instanceof Error ? err.message : String(err);
         if (attempt === maxRetries - 1) {
           this.logDelivery(projectId, notificationId, payload.event, "failed", errorDetail);
-          log8.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
+          log9.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
         }
       }
       if (attempt < maxRetries - 1) {
@@ -16059,7 +14759,7 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-var log9 = createLogger("RunCoordinator");
+var log10 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
     this.notifier = notifier;
@@ -16081,23 +14781,23 @@ var RunCoordinator = class {
           try {
             await this.onInsightsGenerated(runId, projectId, result);
           } catch (err) {
-            log9.error("insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+            log10.error("insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
           }
         }
       }
     } catch (err) {
-      log9.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+      log10.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
     }
     try {
       await this.notifier.onRunCompleted(runId, projectId);
     } catch (err) {
-      log9.error("notifier.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+      log10.error("notifier.failed", { runId, error: err instanceof Error ? err.message : String(err) });
     }
     if (this.onAeroEvent) {
       try {
         await this.onAeroEvent({ runId, projectId, insightCount, criticalOrHigh });
       } catch (err) {
-        log9.error("aero.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+        log10.error("aero.failed", { runId, error: err instanceof Error ? err.message : String(err) });
       }
     }
   }
@@ -16108,8 +14808,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";
 
@@ -16210,26 +14910,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) {
@@ -16250,13 +14950,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),
@@ -16299,8 +14999,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,
@@ -16854,10 +15554,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()}
 
 ---
@@ -17041,7 +15741,7 @@ async function compactMessages(args) {
 }
 
 // src/agent/session-registry.ts
-var log10 = createLogger("SessionRegistry");
+var log11 = createLogger("SessionRegistry");
 var MAX_HYDRATE_NOTES = 20;
 var MAX_HYDRATE_BYTES = 32 * 1024;
 function escapeMemoryFragment(value) {
@@ -17272,13 +15972,13 @@ ${lines.join("\n")}
       agent.state.messages = result.messages;
       agent.state.systemPrompt = this.buildHydratedSystemPrompt(projectId, row.systemPrompt);
       this.save(projectName);
-      log10.info("compaction.completed", {
+      log11.info("compaction.completed", {
         projectName,
         removedCount: result.removedCount,
         summaryBytes: Buffer.byteLength(result.summary, "utf8")
       });
     } catch (err) {
-      log10.error("compaction.failed", {
+      log11.error("compaction.failed", {
         projectName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -17375,7 +16075,7 @@ ${lines.join("\n")}
       await agent.prompt(msgs);
       this.save(projectName);
     } catch (err) {
-      log10.error("drain.failed", {
+      log11.error("drain.failed", {
         projectName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -17646,593 +16346,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";
 
@@ -18255,13 +16368,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,
@@ -18353,7 +16466,7 @@ function formatAuditFactorScore(factor) {
 }
 
 // src/snapshot-service.ts
-var log11 = createLogger("Snapshot");
+var log12 = createLogger("Snapshot");
 var ANALYSIS_PROVIDER_PRIORITY = ["openai", "claude", "gemini", "perplexity", "local"];
 var SNAPSHOT_QUERY_COUNT = 6;
 var ProviderExecutionGate2 = class {
@@ -18496,7 +16609,7 @@ var SnapshotService = class {
       return mapAuditReport(report);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log11.warn("audit.failed", { homepageUrl, error: message });
+      log12.warn("audit.failed", { homepageUrl, error: message });
       return {
         url: homepageUrl,
         finalUrl: homepageUrl,
@@ -18526,7 +16639,7 @@ var SnapshotService = class {
           phrases: parsedPhrases
         };
       } catch (err) {
-        log11.warn("profile.generation-failed", {
+        log12.warn("profile.generation-failed", {
           domain: ctx.domain,
           provider: ctx.analysisProvider.adapter.name,
           error: err instanceof Error ? err.message : String(err)
@@ -18668,7 +16781,7 @@ var SnapshotService = class {
         recommendedActions: uniqueStrings(parsed.recommendedActions ?? []).slice(0, 4)
       };
     } catch (err) {
-      log11.warn("response.analysis-failed", {
+      log12.warn("response.analysis-failed", {
         provider: ctx.analysisProvider.adapter.name,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -18953,7 +17066,7 @@ function clipText(value, length) {
 // src/server.ts
 var _require2 = createRequire3(import.meta.url);
 var { version: PKG_VERSION } = _require2("../package.json");
-var log12 = createLogger("Server");
+var log13 = createLogger("Server");
 var DEFAULT_QUOTA = {
   maxConcurrency: 2,
   maxRequestsPerMinute: 10,
@@ -19040,7 +17153,7 @@ function applyLegacyCredentials(rows, config) {
   }
   if (migratedGoogle > 0) {
     saveConfigPatch({ google: config.google });
-    log12.info("credentials.migrated", { type: "google", count: migratedGoogle });
+    log13.info("credentials.migrated", { type: "google", count: migratedGoogle });
   }
   let migratedGa4 = 0;
   for (const row of rows.ga4) {
@@ -19058,7 +17171,7 @@ function applyLegacyCredentials(rows, config) {
   }
   if (migratedGa4 > 0) {
     saveConfigPatch({ ga4: config.ga4 });
-    log12.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
+    log13.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
   }
 }
 async function createServer(opts) {
@@ -19090,11 +17203,11 @@ async function createServer(opts) {
     applyLegacyCredentials(legacyRows, opts.config);
     dropLegacyCredentialColumns(opts.db);
   } catch (err) {
-    log12.warn("credentials.migration.failed", {
+    log13.warn("credentials.migration.failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  log12.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
+  log13.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
     const p = providers[k];
     return p?.apiKey || p?.baseUrl || p?.vertexProject;
   }) });
@@ -19154,8 +17267,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."
@@ -19749,10 +17862,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;
@@ -19770,8 +17883,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" });
@@ -19791,8 +17904,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" });
@@ -19861,31 +17974,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,
@@ -19893,7 +17986,6 @@ export {
   determineCitationState,
   computeCompetitorOverlap,
   extractRecommendedCompetitors,
-  createApiClient,
   setGoogleAuthConfig,
   formatAuditFactorScore,
   listAgentProviders,