@ainyc/canonry 2.2.3 → 2.3.1

package/dist/{chunk-MXUOJWNL.js → chunk-JXOUZ6JH.js}

@@ -4,8 +4,11 @@ import {
   agentSessions,
   apiKeys,
   auditLog,
+  backlinkDomains,
+  backlinkSummaries,
   bingCoverageSnapshots,
   bingUrlInspections,
+  ccReleaseSyncs,
   competitors,
   createLogger,
   dropLegacyCredentialColumns,
@@ -27,7 +30,7 @@ import {
   runs,
   schedules,
   usageCounters
-} from "./chunk-TAII35VC.js";
+} from "./chunk-CW6CAPBQ.js";
 
 // src/config.ts
 import fs from "fs";
@@ -342,12 +345,12 @@ function printCliError(err, format) {
 }
 
 // src/server.ts
-import { createRequire as createRequire2 } from "module";
-import crypto24 from "crypto";
-import fs8 from "fs";
-import path9 from "path";
+import { createRequire as createRequire3 } from "module";
+import crypto27 from "crypto";
+import fs12 from "fs";
+import path15 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { eq as eq26 } from "drizzle-orm";
+import { eq as eq29 } from "drizzle-orm";
 import Fastify from "fastify";
 
 // ../contracts/src/config-schema.ts
@@ -616,6 +619,9 @@ function agentBusy(projectName) {
     409
   );
 }
+function missingDependency(message, details) {
+  return new AppError("MISSING_DEPENDENCY", message, 422, details);
+}
 
 // ../contracts/src/google.ts
 import { z as z5 } from "zod";
@@ -944,7 +950,8 @@ var runKindSchema = z8.enum([
   "gsc-sync",
   "inspect-sitemap",
   "ga-sync",
-  "bing-inspect"
+  "bing-inspect",
+  "backlink-extract"
 ]);
 var RunKinds = runKindSchema.enum;
 var runTriggerSchema = z8.enum(["manual", "scheduled", "config-apply"]);
@@ -1431,6 +1438,83 @@ 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";
@@ -2463,7 +2547,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 path10 = `${target.url.pathname}${target.url.search}`;
+  const path16 = `${target.url.pathname}${target.url.search}`;
   const headers = {
     "Content-Length": String(Buffer.byteLength(body)),
     "Content-Type": "application/json",
@@ -2479,7 +2563,7 @@ async function deliverWebhook(target, payload, webhookSecret) {
       headers,
       hostname: target.address,
       method: "POST",
-      path: path10,
+      path: path16,
       port,
       timeout: REQUEST_TIMEOUT_MS
     };
@@ -5657,6 +5741,171 @@ var routeCatalog = [
       200: { description: "Health history returned." },
       404: { description: "Project not found." }
     }
+  },
+  {
+    method: "get",
+    path: "/api/v1/backlinks/status",
+    summary: "Get the Common Crawl DuckDB plugin install status",
+    description: "Reports whether @duckdb/node-api is installed in the local plugin dir. Returns MISSING_DEPENDENCY (422) on deployments that cannot host the plugin (e.g. the cloud API).",
+    tags: ["backlinks"],
+    responses: {
+      200: { description: "Install status returned." },
+      422: { description: "Backlinks feature is not available on this deployment." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/backlinks/install",
+    summary: "Install the @duckdb/node-api plugin",
+    description: "Idempotently installs DuckDB into the canonry plugin dir. Returns MISSING_DEPENDENCY (422) when the host cannot perform the install.",
+    tags: ["backlinks"],
+    responses: {
+      200: { description: "Installed (or already present)." },
+      422: { description: "Backlinks feature is not available on this deployment." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/backlinks/syncs",
+    summary: "Queue a workspace-wide Common Crawl release sync",
+    description: "Creates a `cc_release_syncs` row and fires the sync callback. Idempotent: an existing in-flight row for the same release is returned.",
+    tags: ["backlinks"],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["release"],
+            properties: {
+              release: stringSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Existing in-flight sync returned." },
+      201: { description: "Sync queued." },
+      400: { description: "Invalid release id." },
+      422: { description: "Backlinks feature is not available on this deployment." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/backlinks/syncs",
+    summary: "List Common Crawl release syncs",
+    description: "Returns syncs ordered by updatedAt DESC \u2014 re-queued rows surface ahead of untouched newer rows.",
+    tags: ["backlinks"],
+    responses: {
+      200: { description: "Sync history returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/backlinks/syncs/latest",
+    summary: "Get the most recently-updated Common Crawl release sync",
+    tags: ["backlinks"],
+    responses: {
+      200: { description: "Latest sync returned, or null when no sync exists." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/backlinks/releases",
+    summary: "List cached Common Crawl releases on the local filesystem",
+    tags: ["backlinks"],
+    responses: {
+      200: { description: "Cached release metadata returned." }
+    }
+  },
+  {
+    method: "delete",
+    path: "/api/v1/backlinks/cache/{release}",
+    summary: "Prune a cached Common Crawl release",
+    tags: ["backlinks"],
+    parameters: [
+      {
+        name: "release",
+        in: "path",
+        required: true,
+        description: "Release id (e.g. cc-main-2026-jan-feb-mar).",
+        schema: stringSchema
+      }
+    ],
+    responses: {
+      200: { description: "Cache pruned." },
+      400: { description: "Invalid release id." },
+      422: { description: "Backlinks feature is not available on this deployment." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/backlinks/extract",
+    summary: "Extract backlinks for a single project from a cached release",
+    description: 'Creates a `runs` row with kind="backlink-extract" and fires the extract callback. Defaults to the most recent ready release when `release` is omitted.',
+    tags: ["backlinks"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: false,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              release: stringSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      201: { description: "Extract run queued." },
+      400: { description: "Invalid release id." },
+      404: { description: "Project not found." },
+      422: { description: "Backlinks feature is not available on this deployment." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/backlinks/summary",
+    summary: "Get the latest backlink summary for a project",
+    tags: ["backlinks"],
+    parameters: [
+      nameParameter,
+      { name: "release", in: "query", description: "Release id filter.", schema: stringSchema }
+    ],
+    responses: {
+      200: { description: "Summary returned, or null when no backlinks exist." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/backlinks/domains",
+    summary: "Paginate backlink domains for a project",
+    tags: ["backlinks"],
+    parameters: [
+      nameParameter,
+      { name: "release", in: "query", description: "Release id filter.", schema: stringSchema },
+      { name: "limit", in: "query", description: "Max results (1-500).", schema: stringSchema },
+      { name: "offset", in: "query", description: "Pagination offset.", schema: stringSchema }
+    ],
+    responses: {
+      200: { description: "Domain list returned." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/backlinks/history",
+    summary: "Get per-release backlink summaries for a project",
+    tags: ["backlinks"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "History returned oldest-first by queriedAt." },
+      404: { description: "Project not found." }
+    }
   }
 ];
 var canonryLocalRouteCatalog = [
@@ -5791,8 +6040,8 @@ async function openApiRoutes(app, opts = {}) {
     return reply.type("application/json").send(buildOpenApiDocument(opts));
   });
 }
-function buildOperationId(method, path10) {
-  const parts = path10.split("/").filter(Boolean).map((part) => {
+function buildOperationId(method, path16) {
+  const parts = path16.split("/").filter(Boolean).map((part) => {
     if (part.startsWith("{") && part.endsWith("}")) {
       return `by-${part.slice(1, -1)}`;
     }
@@ -9435,10 +9684,10 @@ function buildAuthErrorMessage(res, responseText) {
   }
   return "WordPress credentials are invalid or lack permission for this action";
 }
-async function fetchJson(connection, siteUrl, path10, init) {
+async function fetchJson(connection, siteUrl, path16, init) {
   if (siteUrl.startsWith("http:")) {
   }
-  const res = await fetch(`${normalizeSiteUrl(siteUrl)}${path10}`, {
+  const res = await fetch(`${normalizeSiteUrl(siteUrl)}${path16}`, {
     ...init,
     headers: {
       "Authorization": `Basic ${encodeBasicAuth(connection.username, connection.appPassword)}`,
@@ -10920,6 +11169,566 @@ async function wordpressRoutes(app, opts) {
   });
 }
 
+// ../api-routes/src/backlinks.ts
+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";
+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 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 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`;
+  const vertexFilename = `${release}-domain-vertices.txt.gz`;
+  const edgesFilename = `${release}-domain-edges.txt.gz`;
+  return {
+    vertexUrl: `${base}/${vertexFilename}`,
+    edgesUrl: `${base}/${edgesFilename}`,
+    vertexFilename,
+    edgesFilename
+  };
+}
+
+// ../integration-commoncrawl/src/reverse-domain.ts
+function reverseDomain(domain) {
+  return domain.split(".").reverse().join(".");
+}
+function forwardDomain(revDomain) {
+  return revDomain.split(".").reverse().join(".");
+}
+
+// ../integration-commoncrawl/src/release-id.ts
+function isValidReleaseId(id) {
+  return RELEASE_ID_REGEX.test(id);
+}
+
+// ../integration-commoncrawl/src/downloader.ts
+import { createHash } from "crypto";
+import { createWriteStream } from "fs";
+import fs3 from "fs/promises";
+import path4 from "path";
+import { pipeline } from "stream/promises";
+import { Readable, Transform } from "stream";
+async function downloadFile(opts) {
+  const start = Date.now();
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const sidecarPath = `${opts.destPath}.sha256`;
+  try {
+    const stat = await fs3.stat(opts.destPath);
+    const sidecar = await readSidecar(sidecarPath);
+    const sha2562 = sidecar ?? await hashFile(opts.destPath);
+    if (!sidecar) await writeSidecar(sidecarPath, sha2562);
+    return { bytes: stat.size, sha256: sha2562, cached: true, elapsedMs: Date.now() - start };
+  } catch {
+  }
+  const partialPath = `${opts.destPath}.partial`;
+  await fs3.mkdir(path4.dirname(opts.destPath), { recursive: true });
+  await unlinkIfExists(partialPath);
+  const res = await fetchImpl(opts.url);
+  if (!res.ok || !res.body) {
+    throw new Error(`HTTP ${res.status} ${res.statusText} for ${opts.url}`);
+  }
+  const total = parseContentLength(res.headers.get("content-length"));
+  const hasher = createHash("sha256");
+  let bytes = 0;
+  const hashAndCount = new Transform({
+    transform(chunk, _enc, cb) {
+      hasher.update(chunk);
+      bytes += chunk.length;
+      opts.onProgress?.(bytes, total);
+      cb(null, chunk);
+    }
+  });
+  await pipeline(
+    Readable.fromWeb(res.body),
+    hashAndCount,
+    createWriteStream(partialPath)
+  );
+  const sha256 = hasher.digest("hex");
+  await fs3.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");
+  try {
+    const stream = handle.createReadStream();
+    for await (const chunk of stream) hasher.update(chunk);
+  } finally {
+    await handle.close();
+  }
+  return hasher.digest("hex");
+}
+async function readSidecar(sidecarPath) {
+  try {
+    const raw = await fs3.readFile(sidecarPath, "utf8");
+    const trimmed = raw.trim();
+    return /^[0-9a-f]{64}$/i.test(trimmed) ? trimmed.toLowerCase() : null;
+  } catch {
+    return null;
+  }
+}
+async function writeSidecar(sidecarPath, sha256) {
+  await fs3.writeFile(sidecarPath, `${sha256}
+`);
+}
+async function unlinkIfExists(p) {
+  try {
+    await fs3.unlink(p);
+  } catch {
+  }
+}
+function parseContentLength(value) {
+  if (!value) return null;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) ? n : null;
+}
+
+// ../integration-commoncrawl/src/plugin-resolver.ts
+import fs4 from "fs";
+import { createRequire as createRequire2 } from "module";
+import path5 from "path";
+function pluginDirFor(pkgJson) {
+  return path5.dirname(pkgJson);
+}
+function duckdbPkgJsonFor(pluginDir) {
+  return path5.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)) {
+    throw missingDependency(
+      "@duckdb/node-api is not installed. Run `canonry backlinks install` to enable the backlinks feature.",
+      { pluginDir }
+    );
+  }
+  try {
+    const pluginRequire = createRequire2(duckdbPkg);
+    return pluginRequire("@duckdb/node-api");
+  } catch {
+    throw missingDependency(
+      "@duckdb/node-api is installed but failed to load. Re-run `canonry backlinks install`.",
+      { pluginDir }
+    );
+  }
+}
+function isDuckdbInstalled(opts = {}) {
+  const pkgJson = opts.pluginPkgJson ?? PLUGIN_PKG_JSON;
+  return fs4.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 pkg = JSON.parse(raw);
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// ../integration-commoncrawl/src/plugin-installer.ts
+import { spawn } from "child_process";
+import fs5 from "fs/promises";
+import path6 from "path";
+async function installDuckdb(opts = {}) {
+  const pluginDir = opts.pluginDir ?? PLUGIN_DIR;
+  const pluginPkgJson = path6.join(pluginDir, "package.json");
+  const spec = opts.spec ?? DUCKDB_SPEC;
+  const pkgManager = opts.packageManager ?? "npm";
+  await ensurePluginDir(pluginDir, pluginPkgJson);
+  if (isDuckdbInstalled({ pluginPkgJson })) {
+    const version2 = readInstalledVersion({ pluginPkgJson }) ?? "unknown";
+    return { alreadyPresent: true, version: version2, path: pluginDir };
+  }
+  await runInstall(pkgManager, spec, pluginDir, opts.onLog);
+  if (!isDuckdbInstalled({ pluginPkgJson })) {
+    throw new Error(`${pkgManager} install completed but @duckdb/node-api still cannot be resolved from ${pluginDir}`);
+  }
+  const version = readInstalledVersion({ pluginPkgJson }) ?? "unknown";
+  return { alreadyPresent: false, version, path: pluginDir };
+}
+async function ensurePluginDir(pluginDir = PLUGIN_DIR, pluginPkgJson = PLUGIN_PKG_JSON) {
+  await fs5.mkdir(pluginDir, { recursive: true });
+  try {
+    await fs5.access(pluginPkgJson);
+  } catch {
+    const contents = JSON.stringify({ name: "canonry-plugins", private: true, dependencies: {} }, null, 2);
+    await fs5.writeFile(pluginPkgJson, `${contents}
+`);
+  }
+}
+async function runInstall(pkgManager, spec, pluginDir, onLog) {
+  const args = pkgManager === "pnpm" ? ["add", spec, "--dir", pluginDir] : ["install", spec, "--prefix", pluginDir];
+  await new Promise((resolve, reject) => {
+    const child = spawn(pkgManager, args, {
+      stdio: onLog ? ["ignore", "pipe", "pipe"] : "inherit"
+    });
+    if (onLog) {
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.setEncoding("utf8");
+      child.stdout?.on("data", (chunk) => {
+        for (const line of chunk.split(/\r?\n/)) {
+          if (line.length > 0) onLog(line);
+        }
+      });
+      child.stderr?.on("data", (chunk) => {
+        for (const line of chunk.split(/\r?\n/)) {
+          if (line.length > 0) onLog(line);
+        }
+      });
+    }
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${pkgManager} install exited with code ${code}`));
+    });
+  });
+}
+
+// ../integration-commoncrawl/src/duckdb-query.ts
+async function queryBacklinks(opts) {
+  if (opts.targets.length === 0) return [];
+  const duckdb = opts.duckdb;
+  const reversed = opts.targets.map(reverseDomain);
+  const targetList = reversed.map(quote).join(", ");
+  const limitClause = opts.limitPerTarget ? `QUALIFY row_number() OVER (PARTITION BY t.target_rev_domain ORDER BY v.num_hosts DESC) <= ${Math.floor(opts.limitPerTarget)}` : "";
+  const sql10 = `
+    WITH vertices AS (
+      SELECT * FROM read_csv(
+        ${quote(opts.vertexPath)},
+        delim='	', header=false,
+        columns={'id':'BIGINT','rev_domain':'VARCHAR','num_hosts':'BIGINT'}
+      )
+    ),
+    targets AS (
+      SELECT v.id AS target_id, v.rev_domain AS target_rev_domain
+      FROM vertices v
+      WHERE v.rev_domain IN (${targetList})
+    ),
+    inbound AS (
+      SELECT e.from_id, e.to_id
+      FROM read_csv(
+        ${quote(opts.edgesPath)},
+        delim='	', header=false,
+        columns={'from_id':'BIGINT','to_id':'BIGINT'}
+      ) e
+      WHERE e.to_id IN (SELECT target_id FROM targets)
+    )
+    SELECT
+      t.target_rev_domain,
+      v.rev_domain AS linking_rev_domain,
+      v.num_hosts
+    FROM inbound i
+    JOIN targets t ON t.target_id = i.to_id
+    JOIN vertices v ON v.id = i.from_id
+    ${limitClause}
+    ORDER BY t.target_rev_domain, v.num_hosts DESC
+  `;
+  const instance = await duckdb.DuckDBInstance.create(":memory:");
+  const conn = await instance.connect();
+  let rows;
+  try {
+    const reader = await conn.runAndReadAll(sql10);
+    rows = reader.getRowObjects();
+  } finally {
+    conn.disconnectSync?.();
+    conn.closeSync?.();
+    instance.closeSync?.();
+  }
+  return rows.map((r) => ({
+    targetDomain: forwardDomain(String(r["target_rev_domain"])),
+    linkingDomain: forwardDomain(String(r["linking_rev_domain"])),
+    numHosts: Number(r["num_hosts"])
+  }));
+}
+function quote(s) {
+  return `'${s.replace(/'/g, "''")}'`;
+}
+
+// ../integration-commoncrawl/src/cache.ts
+import fs6 from "fs";
+import path7 from "path";
+function cacheRoot(opts = {}) {
+  return opts.cacheDir ?? CC_CACHE_DIR;
+}
+function directoryBytesAndLastUsed(dir) {
+  let bytes = 0;
+  let latestMtimeMs = 0;
+  const walk = (p) => {
+    let stat;
+    try {
+      stat = fs6.statSync(p);
+    } catch {
+      return;
+    }
+    if (stat.isDirectory()) {
+      let entries;
+      try {
+        entries = fs6.readdirSync(p);
+      } catch {
+        return;
+      }
+      for (const e of entries) walk(path7.join(p, e));
+    } else if (stat.isFile()) {
+      bytes += stat.size;
+      const mtime = Math.max(stat.mtimeMs, stat.atimeMs);
+      if (mtime > latestMtimeMs) latestMtimeMs = mtime;
+    }
+  };
+  walk(dir);
+  return {
+    bytes,
+    lastUsedAt: latestMtimeMs > 0 ? new Date(latestMtimeMs).toISOString() : null
+  };
+}
+function listCachedReleases(opts = {}) {
+  const root = cacheRoot(opts);
+  if (!fs6.existsSync(root)) return [];
+  const entries = fs6.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 stats = directoryBytesAndLastUsed(dir);
+    result.push({ release: entry.name, bytes: stats.bytes, lastUsedAt: stats.lastUsedAt });
+  }
+  result.sort((a, b) => (b.lastUsedAt ?? "").localeCompare(a.lastUsedAt ?? ""));
+  return result;
+}
+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 });
+}
+
+// ../api-routes/src/backlinks.ts
+var BACKLINKS_UNSUPPORTED_MESSAGE = "Backlinks sync and install are only available from a local canonry install. Run `canonry backlinks install` locally to use this feature.";
+var NON_TERMINAL_SYNC_STATUSES = /* @__PURE__ */ new Set([
+  CcReleaseSyncStatuses.queued,
+  CcReleaseSyncStatuses.downloading,
+  CcReleaseSyncStatuses.querying
+]);
+function mapSyncRow(row) {
+  return {
+    id: row.id,
+    release: row.release,
+    status: row.status,
+    phaseDetail: row.phaseDetail ?? null,
+    vertexPath: row.vertexPath ?? null,
+    edgesPath: row.edgesPath ?? null,
+    vertexSha256: row.vertexSha256 ?? null,
+    edgesSha256: row.edgesSha256 ?? null,
+    vertexBytes: row.vertexBytes ?? null,
+    edgesBytes: row.edgesBytes ?? null,
+    projectsProcessed: row.projectsProcessed ?? null,
+    domainsDiscovered: row.domainsDiscovered ?? null,
+    downloadStartedAt: row.downloadStartedAt ?? null,
+    downloadFinishedAt: row.downloadFinishedAt ?? null,
+    queryStartedAt: row.queryStartedAt ?? null,
+    queryFinishedAt: row.queryFinishedAt ?? null,
+    error: row.error ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function mapSummaryRow(row) {
+  return {
+    projectId: row.projectId,
+    release: row.release,
+    targetDomain: row.targetDomain,
+    totalLinkingDomains: row.totalLinkingDomains,
+    totalHosts: row.totalHosts,
+    top10HostsShare: row.top10HostsShare,
+    queriedAt: row.queriedAt
+  };
+}
+function mapRunRow(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    kind: row.kind,
+    status: row.status,
+    trigger: row.trigger,
+    location: row.location ?? null,
+    startedAt: row.startedAt ?? null,
+    finishedAt: row.finishedAt ?? null,
+    error: row.error ?? null,
+    createdAt: row.createdAt
+  };
+}
+function latestSummaryForProject(db, projectId, release) {
+  const condition = release ? and7(eq18(backlinkSummaries.projectId, projectId), eq18(backlinkSummaries.release, release)) : eq18(backlinkSummaries.projectId, projectId);
+  return db.select().from(backlinkSummaries).where(condition).orderBy(desc8(backlinkSummaries.queriedAt)).limit(1).get();
+}
+async function backlinksRoutes(app, opts) {
+  app.get("/backlinks/status", async (_request, reply) => {
+    if (!opts.getBacklinksStatus) {
+      throw missingDependency(BACKLINKS_UNSUPPORTED_MESSAGE);
+    }
+    return reply.send(opts.getBacklinksStatus());
+  });
+  app.post("/backlinks/install", async (_request, reply) => {
+    if (!opts.onInstallBacklinks) {
+      throw missingDependency(BACKLINKS_UNSUPPORTED_MESSAGE);
+    }
+    const result = await opts.onInstallBacklinks();
+    return reply.status(200).send(result);
+  });
+  app.post("/backlinks/syncs", async (request, reply) => {
+    const release = request.body?.release;
+    if (!release || !isValidReleaseId(release)) {
+      throw validationError("Invalid release id. Expected form: cc-main-YYYY-{jan-feb-mar,apr-may-jun,jul-aug-sep,oct-nov-dec}");
+    }
+    if (!opts.getBacklinksStatus || !opts.onReleaseSyncRequested) {
+      throw missingDependency(BACKLINKS_UNSUPPORTED_MESSAGE);
+    }
+    if (!opts.getBacklinksStatus().duckdbInstalled) {
+      throw missingDependency(
+        "@duckdb/node-api is not installed. Run `canonry backlinks install` to enable the backlinks feature."
+      );
+    }
+    const existing = app.db.select().from(ccReleaseSyncs).where(eq18(ccReleaseSyncs.release, release)).get();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (existing) {
+      if (NON_TERMINAL_SYNC_STATUSES.has(existing.status)) {
+        return reply.status(200).send(mapSyncRow(existing));
+      }
+      app.db.update(ccReleaseSyncs).set({
+        status: CcReleaseSyncStatuses.queued,
+        phaseDetail: null,
+        error: null,
+        updatedAt: now
+      }).where(eq18(ccReleaseSyncs.id, existing.id)).run();
+      opts.onReleaseSyncRequested(existing.id, release);
+      const refreshed = app.db.select().from(ccReleaseSyncs).where(eq18(ccReleaseSyncs.id, existing.id)).get();
+      return reply.status(200).send(mapSyncRow(refreshed));
+    }
+    const id = crypto18.randomUUID();
+    app.db.insert(ccReleaseSyncs).values({
+      id,
+      release,
+      status: CcReleaseSyncStatuses.queued,
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    opts.onReleaseSyncRequested(id, release);
+    const inserted = app.db.select().from(ccReleaseSyncs).where(eq18(ccReleaseSyncs.id, id)).get();
+    return reply.status(201).send(mapSyncRow(inserted));
+  });
+  app.get("/backlinks/syncs/latest", async (_request, reply) => {
+    const row = app.db.select().from(ccReleaseSyncs).orderBy(desc8(ccReleaseSyncs.updatedAt)).limit(1).get();
+    return reply.send(row ? mapSyncRow(row) : null);
+  });
+  app.get("/backlinks/syncs", async (_request, reply) => {
+    const rows = app.db.select().from(ccReleaseSyncs).orderBy(desc8(ccReleaseSyncs.updatedAt)).all();
+    return reply.send(rows.map(mapSyncRow));
+  });
+  app.get("/backlinks/releases", async (_request, reply) => {
+    const releases = opts.listCachedReleases?.() ?? [];
+    return reply.send(releases);
+  });
+  app.delete("/backlinks/cache/:release", async (request, reply) => {
+    const release = request.params.release;
+    if (!isValidReleaseId(release)) {
+      throw validationError("Invalid release id");
+    }
+    if (!opts.onBacklinksPruneCache) {
+      throw missingDependency(BACKLINKS_UNSUPPORTED_MESSAGE);
+    }
+    opts.onBacklinksPruneCache(release);
+    return reply.send({ ok: true });
+  });
+  app.post("/projects/:name/backlinks/extract", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    if (!opts.getBacklinksStatus || !opts.onBacklinkExtractRequested) {
+      throw missingDependency(BACKLINKS_UNSUPPORTED_MESSAGE);
+    }
+    if (!opts.getBacklinksStatus().duckdbInstalled) {
+      throw missingDependency(
+        "@duckdb/node-api is not installed. Run `canonry backlinks install` to enable the backlinks feature."
+      );
+    }
+    const release = request.body?.release;
+    if (release !== void 0 && !isValidReleaseId(release)) {
+      throw validationError("Invalid release id");
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const runId = crypto18.randomUUID();
+    app.db.insert(runs).values({
+      id: runId,
+      projectId: project.id,
+      kind: RunKinds["backlink-extract"],
+      status: RunStatuses.queued,
+      trigger: RunTriggers.manual,
+      createdAt: now
+    }).run();
+    opts.onBacklinkExtractRequested(runId, project.id, release);
+    const run = app.db.select().from(runs).where(eq18(runs.id, runId)).get();
+    return reply.status(201).send(mapRunRow(run));
+  });
+  app.get(
+    "/projects/:name/backlinks/summary",
+    async (request, reply) => {
+      const project = resolveProject(app.db, request.params.name);
+      const row = latestSummaryForProject(app.db, project.id, request.query.release);
+      return reply.send(row ? mapSummaryRow(row) : null);
+    }
+  );
+  app.get("/projects/:name/backlinks/domains", async (request, reply) => {
+    const project = resolveProject(app.db, request.params.name);
+    const summaryRow = latestSummaryForProject(app.db, project.id, request.query.release);
+    const targetRelease = request.query.release ?? summaryRow?.release;
+    if (!targetRelease) {
+      const response2 = { summary: null, total: 0, rows: [] };
+      return reply.send(response2);
+    }
+    const limit = Math.min(Math.max(parseInt(request.query.limit ?? "50", 10) || 50, 1), 500);
+    const offset = Math.max(parseInt(request.query.offset ?? "0", 10) || 0, 0);
+    const domainCondition = and7(
+      eq18(backlinkDomains.projectId, project.id),
+      eq18(backlinkDomains.release, targetRelease)
+    );
+    const totalRow = app.db.select({ count: sql5`count(*)` }).from(backlinkDomains).where(domainCondition).get();
+    const rows = app.db.select({
+      linkingDomain: backlinkDomains.linkingDomain,
+      numHosts: backlinkDomains.numHosts
+    }).from(backlinkDomains).where(domainCondition).orderBy(desc8(backlinkDomains.numHosts)).limit(limit).offset(offset).all();
+    const response = {
+      summary: summaryRow ? mapSummaryRow(summaryRow) : null,
+      total: Number(totalRow?.count ?? 0),
+      rows
+    };
+    return reply.send(response);
+  });
+  app.get(
+    "/projects/:name/backlinks/history",
+    async (request, reply) => {
+      const project = resolveProject(app.db, request.params.name);
+      const rows = app.db.select().from(backlinkSummaries).where(eq18(backlinkSummaries.projectId, project.id)).orderBy(asc2(backlinkSummaries.queriedAt)).all();
+      const response = rows.map((r) => ({
+        release: r.release,
+        totalLinkingDomains: r.totalLinkingDomains,
+        totalHosts: r.totalHosts,
+        top10HostsShare: r.top10HostsShare,
+        queriedAt: r.queriedAt
+      }));
+      return reply.send(response);
+    }
+  );
+}
+
 // ../api-routes/src/index.ts
 async function apiRoutes(app, opts) {
   app.decorate("db", opts.db);
@@ -11028,6 +11837,14 @@ async function apiRoutes(app, opts) {
       googleConnectionStore: opts.googleConnectionStore,
       getGoogleAuthConfig: opts.getGoogleAuthConfig
     });
+    await api.register(backlinksRoutes, {
+      getBacklinksStatus: opts.getBacklinksStatus,
+      onInstallBacklinks: opts.onInstallBacklinks,
+      onReleaseSyncRequested: opts.onReleaseSyncRequested,
+      onBacklinkExtractRequested: opts.onBacklinkExtractRequested,
+      onBacklinksPruneCache: opts.onBacklinksPruneCache,
+      listCachedReleases: opts.listCachedReleases
+    });
     if (opts.registerAuthenticatedRoutes) {
       await opts.registerAuthenticatedRoutes(api);
     }
@@ -11035,7 +11852,7 @@ async function apiRoutes(app, opts) {
 }
 
 // src/server.ts
-import os5 from "os";
+import os6 from "os";
 
 // ../provider-gemini/src/normalize.ts
 import { GoogleGenAI } from "@google/genai";
@@ -12423,8 +13240,8 @@ var localAdapter = {
 };
 
 // ../provider-cdp/src/adapter.ts
-import path4 from "path";
-import os3 from "os";
+import path9 from "path";
+import os4 from "os";
 
 // ../provider-cdp/src/connection.ts
 import CDP from "chrome-remote-interface";
@@ -12788,12 +13605,12 @@ function sleep2(ms) {
 }
 
 // ../provider-cdp/src/screenshot.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs7 from "fs";
+import path8 from "path";
 async function captureElementScreenshot(client, selector, outputPath) {
-  const dir = path3.dirname(outputPath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(outputPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
   let clip;
   try {
@@ -12827,7 +13644,7 @@ async function captureElementScreenshot(client, selector, outputPath) {
   }
   const { data } = await client.Page.captureScreenshot(screenshotParams);
   const buffer = Buffer.from(data, "base64");
-  fs3.writeFileSync(outputPath, buffer);
+  fs7.writeFileSync(outputPath, buffer);
   return outputPath;
 }
 
@@ -12888,7 +13705,7 @@ function getConnection(config) {
   return conn;
 }
 function getScreenshotDir2() {
-  return path4.join(os3.homedir(), ".canonry", "screenshots");
+  return path9.join(os4.homedir(), ".canonry", "screenshots");
 }
 var cdpChatgptAdapter = {
   name: "cdp:chatgpt",
@@ -12952,7 +13769,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 = path4.join(getScreenshotDir2(), `${screenshotId}.png`);
+      const screenshotPath = path9.join(getScreenshotDir2(), `${screenshotId}.png`);
       let capturedScreenshotPath;
       try {
         capturedScreenshotPath = await captureElementScreenshot(
@@ -13488,11 +14305,11 @@ function removeWordpressConnection(config, projectName) {
 }
 
 // src/job-runner.ts
-import crypto18 from "crypto";
-import fs4 from "fs";
-import path5 from "path";
-import os4 from "os";
-import { and as and7, eq as eq18, inArray as inArray3, sql as sql5 } from "drizzle-orm";
+import crypto19 from "crypto";
+import fs8 from "fs";
+import path10 from "path";
+import os5 from "os";
+import { and as and8, eq as eq19, inArray as inArray3, sql as sql6 } from "drizzle-orm";
 
 // src/citation-utils.ts
 function domainMatches(domain, canonicalDomain) {
@@ -13728,7 +14545,7 @@ var JobRunner = class {
     if (stale.length === 0) return;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     for (const run of stale) {
-      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq18(runs.id, run.id)).run();
+      this.db.update(runs).set({ status: "failed", finishedAt: now, error: "Server restarted while run was in progress" }).where(eq19(runs.id, run.id)).run();
       log.warn("run.recovered-stale", { runId: run.id, previousStatus: run.status });
     }
   }
@@ -13756,10 +14573,10 @@ var JobRunner = class {
         throw new Error(`Run ${runId} is not executable from status '${existingRun.status}'`);
       }
       if (existingRun.status === "queued") {
-        this.db.update(runs).set({ status: "running", startedAt: now }).where(and7(eq18(runs.id, runId), eq18(runs.status, "queued"))).run();
+        this.db.update(runs).set({ status: "running", startedAt: now }).where(and8(eq19(runs.id, runId), eq19(runs.status, "queued"))).run();
       }
       this.throwIfRunCancelled(runId);
-      const project = this.db.select().from(projects).where(eq18(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq19(projects.id, projectId)).get();
       if (!project) {
         throw new Error(`Project ${projectId} not found`);
       }
@@ -13779,8 +14596,8 @@ var JobRunner = class {
         throw new Error("No providers configured. Add at least one provider API key.");
       }
       log.info("run.dispatch", { runId, providerCount: activeProviders.length, providers: activeProviders.map((p) => p.adapter.name) });
-      projectKeywords = this.db.select().from(keywords).where(eq18(keywords.projectId, projectId)).all();
-      const projectCompetitors = this.db.select().from(competitors).where(eq18(competitors.projectId, projectId)).all();
+      projectKeywords = this.db.select().from(keywords).where(eq19(keywords.projectId, projectId)).all();
+      const projectCompetitors = this.db.select().from(competitors).where(eq19(competitors.projectId, projectId)).all();
       const competitorDomains = projectCompetitors.map((c) => c.domain);
       const allDomains = effectiveDomains({
         canonicalDomain: project.canonicalDomain,
@@ -13796,7 +14613,7 @@ var JobRunner = class {
       const todayPeriod = getCurrentUsageDay();
       for (const p of activeProviders) {
         const providerScope = `${projectId}:${p.adapter.name}`;
-        const providerUsage = this.db.select().from(usageCounters).where(eq18(usageCounters.scope, providerScope)).all().filter((r) => r.period === todayPeriod && r.metric === "queries").reduce((sum, r) => sum + r.count, 0);
+        const providerUsage = this.db.select().from(usageCounters).where(eq19(usageCounters.scope, providerScope)).all().filter((r) => r.period === todayPeriod && r.metric === "queries").reduce((sum, r) => sum + r.count, 0);
         const limit = p.config.quotaPolicy.maxRequestsPerDay;
         if (providerUsage + queriesPerProvider > limit) {
           throw new Error(
@@ -13855,12 +14672,12 @@ var JobRunner = class {
               competitorDomains
             );
             let screenshotRelPath = null;
-            if (raw.screenshotPath && fs4.existsSync(raw.screenshotPath)) {
-              const snapshotId = crypto18.randomUUID();
-              const screenshotDir = path5.join(os4.homedir(), ".canonry", "screenshots", runId);
-              if (!fs4.existsSync(screenshotDir)) fs4.mkdirSync(screenshotDir, { recursive: true });
-              const destPath = path5.join(screenshotDir, `${snapshotId}.png`);
-              fs4.renameSync(raw.screenshotPath, destPath);
+            if (raw.screenshotPath && fs8.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);
               screenshotRelPath = `${runId}/${snapshotId}.png`;
               this.db.insert(querySnapshots).values({
                 id: snapshotId,
@@ -13886,7 +14703,7 @@ var JobRunner = class {
               }).run();
             } else {
               this.db.insert(querySnapshots).values({
-                id: crypto18.randomUUID(),
+                id: crypto19.randomUUID(),
                 runId,
                 keywordId: kw.id,
                 provider: providerName,
@@ -13937,12 +14754,12 @@ var JobRunner = class {
       const someFailed = providerErrors.size > 0;
       if (allFailed) {
         const errorDetail = JSON.stringify(Object.fromEntries(providerErrors));
-        this.db.update(runs).set({ status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq18(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "failed", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq19(runs.id, runId)).run();
       } else if (someFailed) {
         const errorDetail = JSON.stringify(Object.fromEntries(providerErrors));
-        this.db.update(runs).set({ status: "partial", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq18(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "partial", finishedAt: (/* @__PURE__ */ new Date()).toISOString(), error: errorDetail }).where(eq19(runs.id, runId)).run();
       } else {
-        this.db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq18(runs.id, runId)).run();
+        this.db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq19(runs.id, runId)).run();
       }
       this.flushProviderUsage(projectId, providerDispatchCounts);
       const finalStatus = allFailed ? "failed" : someFailed ? "partial" : "completed";
@@ -13977,7 +14794,7 @@ var JobRunner = class {
         status: "failed",
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: errorMessage
-      }).where(eq18(runs.id, runId)).run();
+      }).where(eq19(runs.id, runId)).run();
       this.flushProviderUsage(projectId, providerDispatchCounts);
       trackEvent("run.completed", {
         status: "failed",
@@ -13998,7 +14815,7 @@ var JobRunner = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const period = now.slice(0, 10);
     this.db.insert(usageCounters).values({
-      id: crypto18.randomUUID(),
+      id: crypto19.randomUUID(),
       scope,
       period,
       metric,
@@ -14006,7 +14823,7 @@ var JobRunner = class {
       updatedAt: now
     }).onConflictDoUpdate({
       target: [usageCounters.scope, usageCounters.period, usageCounters.metric],
-      set: { count: sql5`${usageCounters.count} + ${count}`, updatedAt: now }
+      set: { count: sql6`${usageCounters.count} + ${count}`, updatedAt: now }
     }).run();
   }
   flushProviderUsage(projectId, providerDispatchCounts) {
@@ -14020,7 +14837,7 @@ var JobRunner = class {
       status: runs.status,
       finishedAt: runs.finishedAt,
       error: runs.error
-    }).from(runs).where(eq18(runs.id, runId)).get();
+    }).from(runs).where(eq19(runs.id, runId)).get();
   }
   isRunCancelled(runId) {
     return this.getRunState(runId)?.status === "cancelled";
@@ -14036,7 +14853,7 @@ var JobRunner = class {
       this.db.update(runs).set({
         finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
         error: currentRun.error ?? "Cancelled by user"
-      }).where(eq18(runs.id, runId)).run();
+      }).where(eq19(runs.id, runId)).run();
     }
     trackEvent("run.completed", {
       status: "cancelled",
@@ -14058,8 +14875,8 @@ function getCurrentUsageDay() {
 }
 
 // src/gsc-sync.ts
-import crypto19 from "crypto";
-import { eq as eq19, and as and8, sql as sql6 } from "drizzle-orm";
+import crypto20 from "crypto";
+import { eq as eq20, and as and9, sql as sql7 } from "drizzle-orm";
 var log2 = createLogger("GscSync");
 function formatDate2(d) {
   return d.toISOString().split("T")[0];
@@ -14071,13 +14888,13 @@ function daysAgo(n) {
 }
 async function executeGscSync(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq19(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq20(runs.id, runId)).run();
   try {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getGoogleAuthConfig(opts.config);
     if (!googleClientId || !googleClientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq19(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq20(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -14111,10 +14928,10 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     log2.info("fetch.complete", { runId, projectId, rowCount: rows.length });
     db.delete(gscSearchData).where(
-      and8(
-        eq19(gscSearchData.projectId, projectId),
-        sql6`${gscSearchData.date} >= ${startDate}`,
-        sql6`${gscSearchData.date} <= ${endDate}`
+      and9(
+        eq20(gscSearchData.projectId, projectId),
+        sql7`${gscSearchData.date} >= ${startDate}`,
+        sql7`${gscSearchData.date} <= ${endDate}`
       )
     ).run();
     const batchSize = 500;
@@ -14124,7 +14941,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       for (const row of batch) {
         const [query, page, country, device, date] = row.keys;
         db.insert(gscSearchData).values({
-          id: crypto19.randomUUID(),
+          id: crypto20.randomUUID(),
           projectId,
           syncRunId: runId,
           date: date ?? "",
@@ -14158,7 +14975,7 @@ async function executeGscSync(db, runId, projectId, opts) {
         const rich = ir.richResultsResult;
         const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
         db.insert(gscUrlInspections).values({
-          id: crypto19.randomUUID(),
+          id: crypto20.randomUUID(),
           projectId,
           syncRunId: runId,
           url: pageUrl,
@@ -14179,7 +14996,7 @@ async function executeGscSync(db, runId, projectId, opts) {
         log2.error("inspect.url-failed", { runId, projectId, url: pageUrl, error: err instanceof Error ? err.message : String(err) });
       }
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq19(gscUrlInspections.projectId, projectId)).all();
+    const allInspections = db.select().from(gscUrlInspections).where(eq20(gscUrlInspections.projectId, projectId)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       const existing = latestByUrl.get(row.url);
@@ -14200,9 +15017,9 @@ async function executeGscSync(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = formatDate2(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and8(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and9(eq20(gscCoverageSnapshots.projectId, projectId), eq20(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
-      id: crypto19.randomUUID(),
+      id: crypto20.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -14211,19 +15028,19 @@ async function executeGscSync(db, runId, projectId, opts) {
       reasonBreakdown: JSON.stringify(reasonCounts),
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }).run();
-    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq19(runs.id, runId)).run();
+    db.update(runs).set({ status: "completed", finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(runs.id, runId)).run();
     log2.info("sync.completed", { runId, projectId, searchDataRows: rows.length, urlInspections: topPages.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(eq19(runs.id, runId)).run();
+    db.update(runs).set({ status: "failed", error: errorMsg, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(runs.id, runId)).run();
     log2.error("sync.failed", { runId, projectId, error: errorMsg });
     throw err;
   }
 }
 
 // src/gsc-inspect-sitemap.ts
-import crypto20 from "crypto";
-import { eq as eq20, and as and9 } from "drizzle-orm";
+import crypto21 from "crypto";
+import { eq as eq21, and as and10 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var LOC_REGEX = /<loc>\s*([^<]+?)\s*<\/loc>/gi;
@@ -14292,13 +15109,13 @@ async function parseSitemapRecursive(url, urls, depth) {
 var log3 = createLogger("InspectSitemap");
 async function executeInspectSitemap(db, runId, projectId, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.update(runs).set({ status: "running", startedAt: now }).where(eq20(runs.id, runId)).run();
+  db.update(runs).set({ status: "running", startedAt: now }).where(eq21(runs.id, runId)).run();
   try {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getGoogleAuthConfig(opts.config);
     if (!googleClientId || !googleClientSecret) {
       throw new Error("Google OAuth is not configured in the local Canonry config");
     }
-    const project = db.select().from(projects).where(eq20(projects.id, projectId)).get();
+    const project = db.select().from(projects).where(eq21(projects.id, projectId)).get();
     if (!project) {
       throw new Error(`Project not found: ${projectId}`);
     }
@@ -14339,7 +15156,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         const rich = ir.richResultsResult;
         const inspectedAt = (/* @__PURE__ */ new Date()).toISOString();
         db.insert(gscUrlInspections).values({
-          id: crypto20.randomUUID(),
+          id: crypto21.randomUUID(),
           projectId,
           syncRunId: runId,
           url: pageUrl,
@@ -14366,7 +15183,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
         await new Promise((r) => setTimeout(r, 1e3));
       }
     }
-    const allInspections = db.select().from(gscUrlInspections).where(eq20(gscUrlInspections.projectId, projectId)).all();
+    const allInspections = db.select().from(gscUrlInspections).where(eq21(gscUrlInspections.projectId, projectId)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     for (const row of allInspections) {
       const existing = latestByUrl.get(row.url);
@@ -14387,9 +15204,9 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and9(eq20(gscCoverageSnapshots.projectId, projectId), eq20(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and10(eq21(gscCoverageSnapshots.projectId, projectId), eq21(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
-      id: crypto20.randomUUID(),
+      id: crypto21.randomUUID(),
       projectId,
       syncRunId: runId,
       date: snapshotDate,
@@ -14399,16 +15216,304 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }).run();
     const status = errors > 0 && inspected > 0 ? "partial" : errors === urls.length ? "failed" : "completed";
-    db.update(runs).set({ status, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq20(runs.id, runId)).run();
+    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 });
   } 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(eq20(runs.id, runId)).run();
+    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 });
     throw err;
   }
 }
 
+// src/commoncrawl-sync.ts
+import crypto22 from "crypto";
+import path11 from "path";
+import { and as and11, eq as eq22, sql as sql8 } from "drizzle-orm";
+var log4 = createLogger("CommonCrawlSync");
+var INSERT_CHUNK_SIZE = 1e4;
+function defaultDeps() {
+  return {
+    downloadFile,
+    queryBacklinks,
+    loadDuckdb,
+    now: () => /* @__PURE__ */ new Date(),
+    cacheDir: CC_CACHE_DIR
+  };
+}
+async function executeReleaseSync(db, syncId, opts) {
+  const deps = { ...defaultDeps(), ...opts.deps };
+  const release = opts.release;
+  try {
+    if (!isValidReleaseId(release)) {
+      throw new Error(`Invalid release id: ${release}`);
+    }
+    const downloadStartedAt = deps.now().toISOString();
+    db.update(ccReleaseSyncs).set({
+      status: CcReleaseSyncStatuses.downloading,
+      downloadStartedAt,
+      phaseDetail: "downloading vertices + edges",
+      updatedAt: downloadStartedAt,
+      error: null
+    }).where(eq22(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 [vertex, edges] = await Promise.all([
+      deps.downloadFile({ url: paths.vertexUrl, destPath: vertexPath }),
+      deps.downloadFile({ url: paths.edgesUrl, destPath: edgesPath })
+    ]);
+    const downloadFinishedAt = deps.now().toISOString();
+    const queryStartedAt = downloadFinishedAt;
+    db.update(ccReleaseSyncs).set({
+      status: CcReleaseSyncStatuses.querying,
+      downloadFinishedAt,
+      queryStartedAt,
+      phaseDetail: "querying backlinks",
+      vertexPath,
+      edgesPath,
+      vertexBytes: vertex.bytes,
+      edgesBytes: edges.bytes,
+      vertexSha256: vertex.sha256,
+      edgesSha256: edges.sha256,
+      updatedAt: downloadFinishedAt
+    }).where(eq22(ccReleaseSyncs.id, syncId)).run();
+    const allProjects = db.select().from(projects).all();
+    const targets = Array.from(new Set(allProjects.map((p) => p.canonicalDomain)));
+    let rows = [];
+    if (targets.length > 0) {
+      const duckdb = deps.loadDuckdb();
+      rows = await deps.queryBacklinks({ vertexPath, edgesPath, targets, duckdb });
+    }
+    const projectsByDomain = /* @__PURE__ */ new Map();
+    for (const p of allProjects) {
+      const ids = projectsByDomain.get(p.canonicalDomain) ?? [];
+      ids.push(p.id);
+      projectsByDomain.set(p.canonicalDomain, ids);
+    }
+    const queriedAt = deps.now().toISOString();
+    db.transaction((tx) => {
+      tx.delete(backlinkDomains).where(eq22(backlinkDomains.releaseSyncId, syncId)).run();
+      tx.delete(backlinkSummaries).where(eq22(backlinkSummaries.releaseSyncId, syncId)).run();
+      const expanded = [];
+      for (const r of rows) {
+        const projectIds = projectsByDomain.get(r.targetDomain);
+        if (!projectIds) continue;
+        for (const projectId of projectIds) {
+          expanded.push({
+            id: crypto22.randomUUID(),
+            projectId,
+            releaseSyncId: syncId,
+            release,
+            targetDomain: r.targetDomain,
+            linkingDomain: r.linkingDomain,
+            numHosts: r.numHosts,
+            createdAt: queriedAt
+          });
+        }
+      }
+      for (let i = 0; i < expanded.length; i += INSERT_CHUNK_SIZE) {
+        const chunk = expanded.slice(i, i + INSERT_CHUNK_SIZE);
+        if (chunk.length > 0) tx.insert(backlinkDomains).values(chunk).run();
+      }
+      const rowsByProject = groupByProject(rows, projectsByDomain);
+      for (const p of allProjects) {
+        const projectRows = rowsByProject.get(p.id) ?? [];
+        const summary = computeSummary(projectRows);
+        tx.insert(backlinkSummaries).values({
+          id: crypto22.randomUUID(),
+          projectId: p.id,
+          releaseSyncId: syncId,
+          release,
+          targetDomain: p.canonicalDomain,
+          totalLinkingDomains: summary.totalLinkingDomains,
+          totalHosts: summary.totalHosts,
+          top10HostsShare: summary.top10HostsShare,
+          queriedAt,
+          createdAt: queriedAt
+        }).onConflictDoUpdate({
+          target: [backlinkSummaries.projectId, backlinkSummaries.release],
+          set: {
+            releaseSyncId: syncId,
+            targetDomain: p.canonicalDomain,
+            totalLinkingDomains: summary.totalLinkingDomains,
+            totalHosts: summary.totalHosts,
+            top10HostsShare: summary.top10HostsShare,
+            queriedAt
+          }
+        }).run();
+      }
+    });
+    const finishedAt = deps.now().toISOString();
+    db.update(ccReleaseSyncs).set({
+      status: CcReleaseSyncStatuses.ready,
+      queryFinishedAt: finishedAt,
+      phaseDetail: null,
+      projectsProcessed: allProjects.length,
+      domainsDiscovered: rows.length,
+      updatedAt: finishedAt,
+      error: null
+    }).where(eq22(ccReleaseSyncs.id, syncId)).run();
+    log4.info("sync.completed", {
+      syncId,
+      release,
+      projectsProcessed: allProjects.length,
+      domainsDiscovered: rows.length
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    const finishedAt = deps.now().toISOString();
+    db.update(ccReleaseSyncs).set({
+      status: CcReleaseSyncStatuses.failed,
+      error: errorMsg,
+      phaseDetail: null,
+      updatedAt: finishedAt
+    }).where(eq22(ccReleaseSyncs.id, syncId)).run();
+    log4.error("sync.failed", { syncId, release, error: errorMsg });
+    throw err;
+  }
+}
+function groupByProject(rows, projectsByDomain) {
+  const out = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const projectIds = projectsByDomain.get(row.targetDomain);
+    if (!projectIds) continue;
+    for (const projectId of projectIds) {
+      const bucket = out.get(projectId) ?? [];
+      bucket.push(row);
+      out.set(projectId, bucket);
+    }
+  }
+  return out;
+}
+function computeSummary(rows) {
+  if (rows.length === 0) {
+    return { totalLinkingDomains: 0, totalHosts: 0, top10HostsShare: "0" };
+  }
+  const sorted = [...rows].sort((a, b) => b.numHosts - a.numHosts);
+  const totalHosts = sorted.reduce((acc, r) => acc + r.numHosts, 0);
+  const top10Hosts = sorted.slice(0, 10).reduce((acc, r) => acc + r.numHosts, 0);
+  const share = totalHosts > 0 ? top10Hosts / totalHosts : 0;
+  return {
+    totalLinkingDomains: rows.length,
+    totalHosts,
+    top10HostsShare: share.toFixed(6)
+  };
+}
+
+// src/backlink-extract.ts
+import crypto23 from "crypto";
+import { and as and12, desc as desc9, eq as eq23 } from "drizzle-orm";
+var log5 = createLogger("BacklinkExtract");
+function defaultDeps2() {
+  return {
+    queryBacklinks,
+    loadDuckdb,
+    now: () => /* @__PURE__ */ new Date()
+  };
+}
+async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
+  const deps = { ...defaultDeps2(), ...opts.deps };
+  const startedAt = deps.now().toISOString();
+  db.update(runs).set({ status: RunStatuses.running, startedAt }).where(eq23(runs.id, runId)).run();
+  try {
+    const project = db.select().from(projects).where(eq23(projects.id, projectId)).get();
+    if (!project) {
+      throw new Error(`Project not found: ${projectId}`);
+    }
+    const sync = opts.release ? db.select().from(ccReleaseSyncs).where(eq23(ccReleaseSyncs.release, opts.release)).get() : db.select().from(ccReleaseSyncs).where(eq23(ccReleaseSyncs.status, CcReleaseSyncStatuses.ready)).orderBy(desc9(ccReleaseSyncs.createdAt)).limit(1).get();
+    if (!sync) {
+      throw new Error("No ready release sync available \u2014 run `canonry backlinks sync` first");
+    }
+    if (sync.status !== CcReleaseSyncStatuses.ready) {
+      throw new Error(`Release ${sync.release} is not ready (status=${sync.status})`);
+    }
+    if (!sync.vertexPath || !sync.edgesPath) {
+      throw new Error(`Release ${sync.release} is missing cached file paths`);
+    }
+    const duckdb = deps.loadDuckdb();
+    const rows = await deps.queryBacklinks({
+      vertexPath: sync.vertexPath,
+      edgesPath: sync.edgesPath,
+      targets: [project.canonicalDomain],
+      duckdb
+    });
+    const queriedAt = deps.now().toISOString();
+    const syncId = sync.id;
+    const release = sync.release;
+    const targetDomain = project.canonicalDomain;
+    db.transaction((tx) => {
+      tx.delete(backlinkDomains).where(
+        and12(eq23(backlinkDomains.projectId, projectId), eq23(backlinkDomains.release, release))
+      ).run();
+      if (rows.length > 0) {
+        const values = rows.map((r) => ({
+          id: crypto23.randomUUID(),
+          projectId,
+          releaseSyncId: syncId,
+          release,
+          targetDomain,
+          linkingDomain: r.linkingDomain,
+          numHosts: r.numHosts,
+          createdAt: queriedAt
+        }));
+        tx.insert(backlinkDomains).values(values).run();
+      }
+      const summary = computeSummary2(rows);
+      tx.insert(backlinkSummaries).values({
+        id: crypto23.randomUUID(),
+        projectId,
+        releaseSyncId: syncId,
+        release,
+        targetDomain,
+        totalLinkingDomains: summary.totalLinkingDomains,
+        totalHosts: summary.totalHosts,
+        top10HostsShare: summary.top10HostsShare,
+        queriedAt,
+        createdAt: queriedAt
+      }).onConflictDoUpdate({
+        target: [backlinkSummaries.projectId, backlinkSummaries.release],
+        set: {
+          releaseSyncId: syncId,
+          targetDomain,
+          totalLinkingDomains: summary.totalLinkingDomains,
+          totalHosts: summary.totalHosts,
+          top10HostsShare: summary.top10HostsShare,
+          queriedAt
+        }
+      }).run();
+    });
+    const finishedAt = deps.now().toISOString();
+    db.update(runs).set({ status: RunStatuses.completed, finishedAt }).where(eq23(runs.id, runId)).run();
+    log5.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();
+    db.update(runs).set({
+      status: RunStatuses.failed,
+      error: errorMsg,
+      finishedAt
+    }).where(eq23(runs.id, runId)).run();
+    log5.error("extract.failed", { runId, projectId, error: errorMsg });
+    throw err;
+  }
+}
+function computeSummary2(rows) {
+  if (rows.length === 0) {
+    return { totalLinkingDomains: 0, totalHosts: 0, top10HostsShare: "0" };
+  }
+  const sorted = [...rows].sort((a, b) => b.numHosts - a.numHosts);
+  const totalHosts = sorted.reduce((acc, r) => acc + r.numHosts, 0);
+  const top10Hosts = sorted.slice(0, 10).reduce((acc, r) => acc + r.numHosts, 0);
+  const share = totalHosts > 0 ? top10Hosts / totalHosts : 0;
+  return {
+    totalLinkingDomains: rows.length,
+    totalHosts,
+    top10HostsShare: share.toFixed(6)
+  };
+}
+
 // src/provider-registry.ts
 var ProviderRegistry = class {
   providers = /* @__PURE__ */ new Map();
@@ -14462,8 +15567,8 @@ var ProviderRegistry = class {
 
 // src/scheduler.ts
 import cron from "node-cron";
-import { eq as eq21 } from "drizzle-orm";
-var log4 = createLogger("Scheduler");
+import { eq as eq24 } from "drizzle-orm";
+var log6 = createLogger("Scheduler");
 var Scheduler = class {
   db;
   callbacks;
@@ -14474,16 +15579,16 @@ var Scheduler = class {
   }
   /** Load all enabled schedules from DB and register cron jobs. */
   start() {
-    const allSchedules = this.db.select().from(schedules).where(eq21(schedules.enabled, 1)).all();
+    const allSchedules = this.db.select().from(schedules).where(eq24(schedules.enabled, 1)).all();
     for (const schedule of allSchedules) {
       const missedRunAt = schedule.nextRunAt;
       this.registerCronTask(schedule);
       if (missedRunAt && new Date(missedRunAt) < /* @__PURE__ */ new Date()) {
-        log4.info("run.catch-up", { projectId: schedule.projectId, missedRunAt });
+        log6.info("run.catch-up", { projectId: schedule.projectId, missedRunAt });
         this.triggerRun(schedule.id, schedule.projectId);
       }
     }
-    log4.info("started", { scheduleCount: allSchedules.length });
+    log6.info("started", { scheduleCount: allSchedules.length });
   }
   /** Stop all cron tasks for graceful shutdown. */
   stop() {
@@ -14499,7 +15604,7 @@ var Scheduler = class {
       this.stopTask(projectId, existing, "Stopped");
       this.tasks.delete(projectId);
     }
-    const schedule = this.db.select().from(schedules).where(eq21(schedules.projectId, projectId)).get();
+    const schedule = this.db.select().from(schedules).where(eq24(schedules.projectId, projectId)).get();
     if (schedule && schedule.enabled === 1) {
       this.registerCronTask(schedule);
     }
@@ -14515,12 +15620,12 @@ var Scheduler = class {
   stopTask(projectId, task, verb) {
     task.stop();
     task.destroy();
-    log4.info(`task.${verb.toLowerCase()}`, { projectId });
+    log6.info(`task.${verb.toLowerCase()}`, { projectId });
   }
   registerCronTask(schedule) {
     const { id: scheduleId, projectId, cronExpr, timezone } = schedule;
     if (!cron.validate(cronExpr)) {
-      log4.error("cron.invalid", { projectId, cronExpr });
+      log6.error("cron.invalid", { projectId, cronExpr });
       return;
     }
     const task = cron.schedule(cronExpr, () => {
@@ -14532,24 +15637,24 @@ var Scheduler = class {
     this.db.update(schedules).set({
       nextRunAt: task.getNextRun()?.toISOString() ?? null,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq21(schedules.id, scheduleId)).run();
+    }).where(eq24(schedules.id, scheduleId)).run();
     const label = schedule.preset ?? cronExpr;
-    log4.info("cron.registered", { projectId, schedule: label, timezone });
+    log6.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(eq21(schedules.id, scheduleId)).get();
+      const currentSchedule = this.db.select().from(schedules).where(eq24(schedules.id, scheduleId)).get();
       if (!currentSchedule || currentSchedule.enabled !== 1) {
-        log4.warn("schedule.stale", { scheduleId, projectId, msg: "schedule no longer exists or is disabled" });
+        log6.warn("schedule.stale", { scheduleId, projectId, msg: "schedule no longer exists or is disabled" });
         this.remove(projectId);
         return;
       }
       const task = this.tasks.get(projectId);
       const nextRunAt = task?.getNextRun()?.toISOString() ?? null;
-      const project = this.db.select().from(projects).where(eq21(projects.id, projectId)).get();
+      const project = this.db.select().from(projects).where(eq24(projects.id, projectId)).get();
       if (!project) {
-        log4.error("project.not-found", { projectId, msg: "skipping scheduled run" });
+        log6.error("project.not-found", { projectId, msg: "skipping scheduled run" });
         this.remove(projectId);
         return;
       }
@@ -14558,7 +15663,7 @@ var Scheduler = class {
       if (project.defaultLocation) {
         const loc = projectLocations.find((l) => l.label === project.defaultLocation);
         if (!loc) {
-          log4.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
+          log6.warn("default-location.stale", { scheduleId, projectId, label: project.defaultLocation });
           return;
         }
         resolvedLocation = loc;
@@ -14572,11 +15677,11 @@ var Scheduler = class {
         location: locationLabel
       });
       if (queueResult.conflict) {
-        log4.info("run.skipped-active", { projectName: project.name, activeRunId: queueResult.activeRunId });
+        log6.info("run.skipped-active", { projectName: project.name, activeRunId: queueResult.activeRunId });
         this.db.update(schedules).set({
           nextRunAt,
           updatedAt: now
-        }).where(eq21(schedules.id, currentSchedule.id)).run();
+        }).where(eq24(schedules.id, currentSchedule.id)).run();
         return;
       }
       const runId = queueResult.runId;
@@ -14584,21 +15689,21 @@ var Scheduler = class {
         lastRunAt: now,
         nextRunAt,
         updatedAt: now
-      }).where(eq21(schedules.id, currentSchedule.id)).run();
+      }).where(eq24(schedules.id, currentSchedule.id)).run();
       const scheduleProviders = parseJsonColumn(currentSchedule.providers, []);
       const providers = scheduleProviders.length > 0 ? scheduleProviders : void 0;
-      log4.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
+      log6.info("run.triggered", { runId, projectName: project.name, providers: providers ?? "all" });
       this.callbacks.onRunCreated(runId, projectId, providers, resolvedLocation);
     } catch (err) {
-      log4.error("trigger.error", { scheduleId, projectId, error: err instanceof Error ? err.message : String(err) });
+      log6.error("trigger.error", { scheduleId, projectId, error: err instanceof Error ? err.message : String(err) });
     }
   }
 };
 
 // src/notifier.ts
-import { eq as eq22, desc as desc8, and as and10, or as or2 } from "drizzle-orm";
-import crypto21 from "crypto";
-var log5 = createLogger("Notifier");
+import { eq as eq25, desc as desc10, and as and13, or as or2 } from "drizzle-orm";
+import crypto24 from "crypto";
+var log7 = createLogger("Notifier");
 var Notifier = class {
   db;
   serverUrl;
@@ -14608,26 +15713,26 @@ var Notifier = class {
   }
   /** Called after a run completes (success, partial, or failed). */
   async onRunCompleted(runId, projectId) {
-    log5.info("run.completed", { runId, projectId });
-    const notifs = this.db.select().from(notifications).where(eq22(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
+    log7.info("run.completed", { runId, projectId });
+    const notifs = this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
     if (notifs.length === 0) {
-      log5.info("notifications.none-enabled", { projectId });
+      log7.info("notifications.none-enabled", { projectId });
       return;
     }
-    log5.info("notifications.found", { projectId, count: notifs.length });
-    const run = this.db.select().from(runs).where(eq22(runs.id, runId)).get();
+    log7.info("notifications.found", { projectId, count: notifs.length });
+    const run = this.db.select().from(runs).where(eq25(runs.id, runId)).get();
     if (!run) {
-      log5.error("run.not-found", { runId, msg: "skipping notification dispatch" });
+      log7.error("run.not-found", { runId, msg: "skipping notification dispatch" });
       return;
     }
-    const project = this.db.select().from(projects).where(eq22(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
     if (!project) {
-      log5.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
+      log7.error("project.not-found", { projectId, msg: "skipping notification dispatch" });
       return;
     }
     const transitions = this.computeTransitions(runId, projectId);
     const events = [];
-    log5.info("run.status", { runId: run.id, status: run.status, projectId });
+    log7.info("run.status", { runId: run.id, status: run.status, projectId });
     if (run.status === "completed" || run.status === "partial") {
       events.push("run.completed");
     }
@@ -14643,7 +15748,7 @@ var Notifier = class {
       if (!config.url) continue;
       const subscribedEvents = config.events;
       const matchingEvents = events.filter((e) => subscribedEvents.includes(e));
-      log5.info("notification.match", { notificationId: notif.id, subscribedEvents, matchedEvents: matchingEvents });
+      log7.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;
@@ -14667,11 +15772,11 @@ var Notifier = class {
     if (criticalInsights.length > 0) insightEvents.push("insight.critical");
     if (highInsights.length > 0) insightEvents.push("insight.high");
     if (insightEvents.length === 0) return;
-    const notifs = this.db.select().from(notifications).where(eq22(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
+    const notifs = this.db.select().from(notifications).where(eq25(notifications.projectId, projectId)).all().filter((n) => n.enabled === 1);
     if (notifs.length === 0) return;
-    const run = this.db.select().from(runs).where(eq22(runs.id, runId)).get();
+    const run = this.db.select().from(runs).where(eq25(runs.id, runId)).get();
     if (!run) return;
-    const project = this.db.select().from(projects).where(eq22(projects.id, projectId)).get();
+    const project = this.db.select().from(projects).where(eq25(projects.id, projectId)).get();
     if (!project) return;
     for (const notif of notifs) {
       const config = parseJsonColumn(notif.config, { url: "", events: [] });
@@ -14702,11 +15807,11 @@ var Notifier = class {
   }
   computeTransitions(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
-      and10(
-        eq22(runs.projectId, projectId),
-        or2(eq22(runs.status, "completed"), eq22(runs.status, "partial"))
+      and13(
+        eq25(runs.projectId, projectId),
+        or2(eq25(runs.status, "completed"), eq25(runs.status, "partial"))
       )
-    ).orderBy(desc8(runs.createdAt)).limit(2).all();
+    ).orderBy(desc10(runs.createdAt)).limit(2).all();
     if (recentRuns.length < 2) return [];
     const currentRunId = recentRuns[0].id;
     const previousRunId = recentRuns[1].id;
@@ -14716,12 +15821,12 @@ var Notifier = class {
       keyword: keywords.keyword,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).leftJoin(keywords, eq22(querySnapshots.keywordId, keywords.id)).where(eq22(querySnapshots.runId, currentRunId)).all();
+    }).from(querySnapshots).leftJoin(keywords, eq25(querySnapshots.keywordId, keywords.id)).where(eq25(querySnapshots.runId, currentRunId)).all();
     const previousSnapshots = this.db.select({
       keywordId: querySnapshots.keywordId,
       provider: querySnapshots.provider,
       citationState: querySnapshots.citationState
-    }).from(querySnapshots).where(eq22(querySnapshots.runId, previousRunId)).all();
+    }).from(querySnapshots).where(eq25(querySnapshots.runId, previousRunId)).all();
     const prevMap = /* @__PURE__ */ new Map();
     for (const s of previousSnapshots) {
       prevMap.set(`${s.keywordId}:${s.provider}`, s.citationState);
@@ -14745,23 +15850,23 @@ var Notifier = class {
     const targetLabel = redactNotificationUrl(url).urlDisplay;
     const targetCheck = await resolveWebhookTarget(url);
     if (!targetCheck.ok) {
-      log5.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
+      log7.error("webhook.ssrf-blocked", { url: targetLabel, reason: targetCheck.message });
       this.logDelivery(projectId, notificationId, payload.event, "failed", `SSRF: ${targetCheck.message}`);
       return;
     }
-    log5.info("webhook.send", { event: payload.event, url: targetLabel });
+    log7.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) {
-          log5.info("webhook.delivered", { event: payload.event, url: targetLabel, httpStatus: response.status });
+          log7.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}`;
-        log5.warn("webhook.attempt-failed", { event: payload.event, url: targetLabel, attempt: attempt + 1, maxRetries, httpStatus: response.status, error: errorDetail });
+        log7.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);
         }
@@ -14769,7 +15874,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);
-          log5.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
+          log7.error("webhook.exhausted", { event: payload.event, url: targetLabel, maxRetries, error: errorDetail });
         }
       }
       if (attempt < maxRetries - 1) {
@@ -14779,7 +15884,7 @@ var Notifier = class {
   }
   logDelivery(projectId, notificationId, event, status, error) {
     this.db.insert(auditLog).values({
-      id: crypto21.randomUUID(),
+      id: crypto24.randomUUID(),
       projectId,
       actor: "scheduler",
       action: `notification.${status}`,
@@ -14792,7 +15897,7 @@ var Notifier = class {
 };
 
 // src/run-coordinator.ts
-var log6 = createLogger("RunCoordinator");
+var log8 = createLogger("RunCoordinator");
 var RunCoordinator = class {
   constructor(notifier, intelligenceService, onInsightsGenerated, onAeroEvent) {
     this.notifier = notifier;
@@ -14814,35 +15919,35 @@ var RunCoordinator = class {
           try {
             await this.onInsightsGenerated(runId, projectId, result);
           } catch (err) {
-            log6.error("insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+            log8.error("insight-webhook.failed", { runId, error: err instanceof Error ? err.message : String(err) });
           }
         }
       }
     } catch (err) {
-      log6.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+      log8.error("intelligence.failed", { runId, error: err instanceof Error ? err.message : String(err) });
     }
     try {
       await this.notifier.onRunCompleted(runId, projectId);
     } catch (err) {
-      log6.error("notifier.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+      log8.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) {
-        log6.error("aero.failed", { runId, error: err instanceof Error ? err.message : String(err) });
+        log8.error("aero.failed", { runId, error: err instanceof Error ? err.message : String(err) });
       }
     }
   }
 };
 
 // src/agent/session-registry.ts
-import crypto23 from "crypto";
-import { eq as eq24 } from "drizzle-orm";
+import crypto26 from "crypto";
+import { eq as eq27 } from "drizzle-orm";
 
 // src/agent/session.ts
-import fs7 from "fs";
-import path8 from "path";
+import fs11 from "fs";
+import path14 from "path";
 import { Agent } from "@mariozechner/pi-agent-core";
 import { registerBuiltInApiProviders } from "@mariozechner/pi-ai";
 
@@ -14943,26 +16048,26 @@ function buildAgentProvidersResponse(config) {
 }
 
 // src/agent/skill-paths.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs9 from "fs";
+import path12 from "path";
 import { fileURLToPath } from "url";
 function resolveAeroSkillDir(pkgDir) {
-  const here = pkgDir ?? path6.dirname(fileURLToPath(import.meta.url));
+  const here = pkgDir ?? path12.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path6.join(here, "../assets/agent-workspace/skills/aero"),
-    path6.join(here, "../../assets/agent-workspace/skills/aero"),
-    path6.join(here, "../../../../skills/aero")
+    path12.join(here, "../assets/agent-workspace/skills/aero"),
+    path12.join(here, "../../assets/agent-workspace/skills/aero"),
+    path12.join(here, "../../../../skills/aero")
   ];
   for (const candidate of candidates) {
-    if (fs5.existsSync(path6.join(candidate, "SKILL.md"))) return candidate;
+    if (fs9.existsSync(path12.join(candidate, "SKILL.md"))) return candidate;
   }
   throw new Error(`Aero skill not found. Searched:
   ${candidates.join("\n  ")}`);
 }
 
 // src/agent/skill-tools.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs10 from "fs";
+import path13 from "path";
 import { Type } from "@sinclair/typebox";
 var MAX_DOC_CHARS = 2e4;
 function textResult(details) {
@@ -14983,13 +16088,13 @@ function parseDescription(body) {
   return "(no description)";
 }
 function scanSkillDocs(skillDir) {
-  const refsDir = path7.join(skillDir ?? resolveAeroSkillDir(), "references");
-  if (!fs6.existsSync(refsDir)) return [];
+  const refsDir = path13.join(skillDir ?? resolveAeroSkillDir(), "references");
+  if (!fs10.existsSync(refsDir)) return [];
   const entries = [];
-  for (const file of fs6.readdirSync(refsDir)) {
+  for (const file of fs10.readdirSync(refsDir)) {
     if (!file.endsWith(".md")) continue;
-    const filePath = path7.join(refsDir, file);
-    const body = fs6.readFileSync(filePath, "utf-8");
+    const filePath = path13.join(refsDir, file);
+    const body = fs10.readFileSync(filePath, "utf-8");
     entries.push({
       slug: file.replace(/\.md$/, ""),
       description: parseDescription(body),
@@ -15032,8 +16137,8 @@ function buildReadSkillDocTool() {
           availableSlugs: docs.map((d) => d.slug)
         });
       }
-      const filePath = path7.join(skillDir, "references", `${match.slug}.md`);
-      const content = fs6.readFileSync(filePath, "utf-8");
+      const filePath = path13.join(skillDir, "references", `${match.slug}.md`);
+      const content = fs10.readFileSync(filePath, "utf-8");
       if (content.length > MAX_DOC_CHARS) {
         return textResult({
           slug: match.slug,
@@ -15057,8 +16162,8 @@ function buildSkillDocTools() {
 import { Type as Type2 } from "@sinclair/typebox";
 
 // src/agent/memory-store.ts
-import crypto22 from "crypto";
-import { and as and11, desc as desc9, eq as eq23, like, sql as sql7 } from "drizzle-orm";
+import crypto25 from "crypto";
+import { and as and14, desc as desc11, eq as eq26, like, sql as sql9 } from "drizzle-orm";
 var COMPACTION_KEY_PREFIX = "compaction:";
 var COMPACTION_NOTES_PER_SESSION = 3;
 function rowToDto(row) {
@@ -15072,7 +16177,7 @@ function rowToDto(row) {
   };
 }
 function listMemoryEntries(db, projectId, opts = {}) {
-  const query = db.select().from(agentMemory).where(eq23(agentMemory.projectId, projectId)).orderBy(desc9(agentMemory.updatedAt));
+  const query = db.select().from(agentMemory).where(eq26(agentMemory.projectId, projectId)).orderBy(desc11(agentMemory.updatedAt));
   const rows = opts.limit === void 0 ? query.all() : query.limit(opts.limit).all();
   return rows.map(rowToDto);
 }
@@ -15086,7 +16191,7 @@ function upsertMemoryEntry(db, args) {
     throw new Error(`memory key prefix "${COMPACTION_KEY_PREFIX}" is reserved for compaction notes`);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const id = crypto22.randomUUID();
+  const id = crypto25.randomUUID();
   db.insert(agentMemory).values({
     id,
     projectId: args.projectId,
@@ -15103,12 +16208,12 @@ function upsertMemoryEntry(db, args) {
       updatedAt: now
     }
   }).run();
-  const row = db.select().from(agentMemory).where(and11(eq23(agentMemory.projectId, args.projectId), eq23(agentMemory.key, args.key))).get();
+  const row = db.select().from(agentMemory).where(and14(eq26(agentMemory.projectId, args.projectId), eq26(agentMemory.key, args.key))).get();
   if (!row) throw new Error("memory upsert produced no row");
   return rowToDto(row);
 }
 function deleteMemoryEntry(db, projectId, key) {
-  const result = db.delete(agentMemory).where(and11(eq23(agentMemory.projectId, projectId), eq23(agentMemory.key, key))).run();
+  const result = db.delete(agentMemory).where(and14(eq26(agentMemory.projectId, projectId), eq26(agentMemory.key, key))).run();
   const changes = result.changes ?? 0;
   return changes > 0;
 }
@@ -15123,7 +16228,7 @@ function writeCompactionNote(db, args) {
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const key = `${COMPACTION_KEY_PREFIX}${args.sessionId}:${now}`;
-  const id = crypto22.randomUUID();
+  const id = crypto25.randomUUID();
   let inserted;
   db.transaction((tx) => {
     tx.insert(agentMemory).values({
@@ -15137,16 +16242,16 @@ function writeCompactionNote(db, args) {
     }).run();
     const sessionPrefix = `${COMPACTION_KEY_PREFIX}${args.sessionId}:`;
     const existing = tx.select({ id: agentMemory.id, updatedAt: agentMemory.updatedAt }).from(agentMemory).where(
-      and11(
-        eq23(agentMemory.projectId, args.projectId),
+      and14(
+        eq26(agentMemory.projectId, args.projectId),
         like(agentMemory.key, `${sessionPrefix}%`)
       )
-    ).orderBy(desc9(agentMemory.updatedAt)).all();
+    ).orderBy(desc11(agentMemory.updatedAt)).all();
     const stale = existing.slice(COMPACTION_NOTES_PER_SESSION).map((r) => r.id);
     if (stale.length > 0) {
-      tx.delete(agentMemory).where(sql7`${agentMemory.id} IN (${sql7.join(stale.map((s) => sql7`${s}`), sql7`, `)})`).run();
+      tx.delete(agentMemory).where(sql9`${agentMemory.id} IN (${sql9.join(stale.map((s) => sql9`${s}`), sql9`, `)})`).run();
     }
-    const row = tx.select().from(agentMemory).where(and11(eq23(agentMemory.projectId, args.projectId), eq23(agentMemory.key, key))).get();
+    const row = tx.select().from(agentMemory).where(and14(eq26(agentMemory.projectId, args.projectId), eq26(agentMemory.key, key))).get();
     if (row) inserted = rowToDto(row);
   });
   if (!inserted) throw new Error("compaction note write produced no row");
@@ -15293,6 +16398,35 @@ function buildGetRunTool(ctx) {
     }
   };
 }
+var BacklinksSchema = Type2.Object({
+  limit: Type2.Optional(
+    Type2.Number({
+      description: "Max linking-domain rows to include. Default 50, max 200.",
+      minimum: 1,
+      maximum: 200
+    })
+  ),
+  release: Type2.Optional(
+    Type2.String({
+      description: "Common Crawl release id (e.g., cc-main-2026-jan-feb-mar). Omit for the most recent release with data."
+    })
+  )
+});
+function buildListBacklinksTool(ctx) {
+  return {
+    name: "list_backlinks",
+    label: "List backlinks",
+    description: "Backlink summary and top linking domains from the most recent ready Common Crawl release. Off-site authority signal that correlates with citation likelihood. Returns null summary when no release sync has completed for this workspace.",
+    parameters: BacklinksSchema,
+    execute: async (_toolCallId, params) => {
+      const response = await ctx.client.backlinksDomains(ctx.projectName, {
+        limit: params.limit ?? 50,
+        release: params.release
+      });
+      return textResult2(response);
+    }
+  };
+}
 var RecallSchema = Type2.Object({
   limit: Type2.Optional(
     Type2.Number({
@@ -15323,7 +16457,8 @@ function buildReadTools(ctx) {
     buildListKeywordsTool(ctx),
     buildListCompetitorsTool(ctx),
     buildGetRunTool(ctx),
-    buildRecallTool(ctx)
+    buildRecallTool(ctx),
+    buildListBacklinksTool(ctx)
   ];
 }
 var RunSweepSchema = Type2.Object({
@@ -15557,10 +16692,10 @@ function ensureBuiltinsRegistered() {
 }
 function loadAeroSystemPrompt(pkgDir) {
   const skillDir = resolveAeroSkillDir(pkgDir);
-  const skillBody = fs7.readFileSync(path8.join(skillDir, "SKILL.md"), "utf-8");
-  const soulPath = path8.join(skillDir, "soul.md");
-  if (!fs7.existsSync(soulPath)) return skillBody;
-  const soulBody = fs7.readFileSync(soulPath, "utf-8");
+  const skillBody = fs11.readFileSync(path14.join(skillDir, "SKILL.md"), "utf-8");
+  const soulPath = path14.join(skillDir, "soul.md");
+  if (!fs11.existsSync(soulPath)) return skillBody;
+  const soulBody = fs11.readFileSync(soulPath, "utf-8");
   return `${soulBody.trimEnd()}
 
 ---
@@ -15744,7 +16879,7 @@ async function compactMessages(args) {
 }
 
 // src/agent/session-registry.ts
-var log7 = createLogger("SessionRegistry");
+var log9 = createLogger("SessionRegistry");
 var MAX_HYDRATE_NOTES = 20;
 var MAX_HYDRATE_BYTES = 32 * 1024;
 function escapeMemoryFragment(value) {
@@ -15793,7 +16928,7 @@ var SessionRegistry = class {
           modelProvider: effectiveProvider,
           modelId: effectiveModelId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }).where(eq24(agentSessions.projectId, projectId)).run();
+        }).where(eq27(agentSessions.projectId, projectId)).run();
       }
       const agent2 = createAeroSession({
         projectName,
@@ -15975,13 +17110,13 @@ ${lines.join("\n")}
       agent.state.messages = result.messages;
       agent.state.systemPrompt = this.buildHydratedSystemPrompt(projectId, row.systemPrompt);
       this.save(projectName);
-      log7.info("compaction.completed", {
+      log9.info("compaction.completed", {
         projectName,
         removedCount: result.removedCount,
         summaryBytes: Buffer.byteLength(result.summary, "utf8")
       });
     } catch (err) {
-      log7.error("compaction.failed", {
+      log9.error("compaction.failed", {
         projectName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -16011,7 +17146,7 @@ ${lines.join("\n")}
       modelProvider: nextProvider,
       modelId: nextModelId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(eq24(agentSessions.projectId, projectId)).run();
+    }).where(eq27(agentSessions.projectId, projectId)).run();
   }
   /** Persist a session's transcript back to the DB. Call after any run settles. */
   save(projectName) {
@@ -16078,7 +17213,7 @@ ${lines.join("\n")}
       await agent.prompt(msgs);
       this.save(projectName);
     } catch (err) {
-      log7.error("drain.failed", {
+      log9.error("drain.failed", {
         projectName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -16173,17 +17308,17 @@ ${lines.join("\n")}
     return id;
   }
   tryResolveProjectId(projectName) {
-    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq24(projects.name, projectName)).get();
+    const row = this.opts.db.select({ id: projects.id }).from(projects).where(eq27(projects.name, projectName)).get();
     return row?.id;
   }
   loadRow(projectId) {
-    const row = this.opts.db.select().from(agentSessions).where(eq24(agentSessions.projectId, projectId)).get();
+    const row = this.opts.db.select().from(agentSessions).where(eq27(agentSessions.projectId, projectId)).get();
     return row ?? null;
   }
   insertRow(params) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.opts.db.insert(agentSessions).values({
-      id: crypto23.randomUUID(),
+      id: crypto26.randomUUID(),
       projectId: params.projectId,
       systemPrompt: params.systemPrompt,
       modelProvider: params.provider ?? params.modelProvider ?? AgentProviderIds.claude,
@@ -16196,14 +17331,14 @@ ${lines.join("\n")}
   }
   updateRow(projectId, patch) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq24(agentSessions.projectId, projectId)).run();
+    this.opts.db.update(agentSessions).set({ ...patch, updatedAt: now }).where(eq27(agentSessions.projectId, projectId)).run();
   }
 };
 
 // src/agent/agent-routes.ts
-import { eq as eq25 } from "drizzle-orm";
+import { eq as eq28 } from "drizzle-orm";
 function resolveProject2(db, name) {
-  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq25(projects.name, name)).get();
+  const row = db.select({ id: projects.id, name: projects.name }).from(projects).where(eq28(projects.name, name)).get();
   if (!row) throw notFound("project", name);
   return row;
 }
@@ -16212,7 +17347,7 @@ function registerAgentRoutes(app, opts) {
     "/projects/:name/agent/transcript",
     async (request) => {
       const project = resolveProject2(opts.db, request.params.name);
-      const row = opts.db.select().from(agentSessions).where(eq25(agentSessions.projectId, project.id)).get();
+      const row = opts.db.select().from(agentSessions).where(eq28(agentSessions.projectId, project.id)).get();
       if (!row) {
         return { messages: [], modelProvider: null, modelId: null, updatedAt: null };
       }
@@ -16236,7 +17371,7 @@ function registerAgentRoutes(app, opts) {
     async (request) => {
       const project = resolveProject2(opts.db, request.params.name);
       opts.sessionRegistry.reset(project.name);
-      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq25(agentSessions.projectId, project.id)).run();
+      opts.db.update(agentSessions).set({ messages: "[]", followUpQueue: "[]", updatedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq28(agentSessions.projectId, project.id)).run();
       return { status: "reset" };
     }
   );
@@ -16398,9 +17533,9 @@ var ApiClient = class {
     }
     return this.probePromise;
   }
-  async request(method, path10, body) {
+  async request(method, path16, body) {
     await this.probeBasePath();
-    const url = `${this.baseUrl}${path10}`;
+    const url = `${this.baseUrl}${path16}`;
     const serializedBody = body != null ? JSON.stringify(body) : void 0;
     const headers = {
       "Authorization": `Bearer ${this.apiKey}`,
@@ -16488,9 +17623,9 @@ var ApiClient = class {
    * structured-error behavior of `request()`; the caller reads `res.body`
    * and releases the response when done.
    */
-  async streamPost(path10, body, signal) {
+  async streamPost(path16, body, signal) {
     await this.probeBasePath();
-    const url = `${this.baseUrl}${path10}`;
+    const url = `${this.baseUrl}${path16}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -16891,6 +18026,46 @@ var ApiClient = class {
     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
@@ -16915,13 +18090,13 @@ function extractHostname(domain) {
 function fetchWithPinnedAddress(target) {
   return new Promise((resolve) => {
     const port = target.url.port ? Number(target.url.port) : 443;
-    const path10 = target.url.pathname + target.url.search;
+    const path16 = target.url.pathname + target.url.search;
     const req = https2.request(
       {
         hostname: target.address,
         family: target.family,
         port,
-        path: path10,
+        path: path16,
         method: "GET",
         timeout: FETCH_TIMEOUT_MS,
         servername: target.url.hostname,
@@ -17013,7 +18188,7 @@ function formatAuditFactorScore(factor) {
 }
 
 // src/snapshot-service.ts
-var log8 = createLogger("Snapshot");
+var log10 = createLogger("Snapshot");
 var ANALYSIS_PROVIDER_PRIORITY = ["openai", "claude", "gemini", "perplexity", "local"];
 var SNAPSHOT_QUERY_COUNT = 6;
 var ProviderExecutionGate2 = class {
@@ -17156,7 +18331,7 @@ var SnapshotService = class {
       return mapAuditReport(report);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log8.warn("audit.failed", { homepageUrl, error: message });
+      log10.warn("audit.failed", { homepageUrl, error: message });
       return {
         url: homepageUrl,
         finalUrl: homepageUrl,
@@ -17186,7 +18361,7 @@ var SnapshotService = class {
           phrases: parsedPhrases
         };
       } catch (err) {
-        log8.warn("profile.generation-failed", {
+        log10.warn("profile.generation-failed", {
           domain: ctx.domain,
           provider: ctx.analysisProvider.adapter.name,
           error: err instanceof Error ? err.message : String(err)
@@ -17328,7 +18503,7 @@ var SnapshotService = class {
         recommendedActions: uniqueStrings(parsed.recommendedActions ?? []).slice(0, 4)
       };
     } catch (err) {
-      log8.warn("response.analysis-failed", {
+      log10.warn("response.analysis-failed", {
         provider: ctx.analysisProvider.adapter.name,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -17611,9 +18786,9 @@ function clipText(value, length) {
 }
 
 // src/server.ts
-var _require2 = createRequire2(import.meta.url);
+var _require2 = createRequire3(import.meta.url);
 var { version: PKG_VERSION } = _require2("../package.json");
-var log9 = createLogger("Server");
+var log11 = createLogger("Server");
 var DEFAULT_QUOTA = {
   maxConcurrency: 2,
   maxRequestsPerMinute: 10,
@@ -17644,7 +18819,7 @@ function summarizeProviderConfig(provider, config) {
   };
 }
 function hashApiKey(key) {
-  return crypto24.createHash("sha256").update(key).digest("hex");
+  return crypto27.createHash("sha256").update(key).digest("hex");
 }
 function parseCookies2(header) {
   if (!header) return {};
@@ -17700,7 +18875,7 @@ function applyLegacyCredentials(rows, config) {
   }
   if (migratedGoogle > 0) {
     saveConfigPatch({ google: config.google });
-    log9.info("credentials.migrated", { type: "google", count: migratedGoogle });
+    log11.info("credentials.migrated", { type: "google", count: migratedGoogle });
   }
   let migratedGa4 = 0;
   for (const row of rows.ga4) {
@@ -17718,7 +18893,7 @@ function applyLegacyCredentials(rows, config) {
   }
   if (migratedGa4 > 0) {
     saveConfigPatch({ ga4: config.ga4 });
-    log9.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
+    log11.info("credentials.migrated", { type: "ga4", count: migratedGa4 });
   }
 }
 async function createServer(opts) {
@@ -17750,11 +18925,11 @@ async function createServer(opts) {
     applyLegacyCredentials(legacyRows, opts.config);
     dropLegacyCredentialColumns(opts.db);
   } catch (err) {
-    log9.warn("credentials.migration.failed", {
+    log11.warn("credentials.migration.failed", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
-  log9.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
+  log11.info("providers.configured", { providers: Object.keys(providers).filter((k) => {
     const p = providers[k];
     return p?.apiKey || p?.baseUrl || p?.vertexProject;
   }) });
@@ -17802,7 +18977,7 @@ async function createServer(opts) {
     intelligenceService,
     (runId, projectId, result) => notifier.dispatchInsightWebhooks(runId, projectId, result),
     async ({ runId, projectId, insightCount, criticalOrHigh }) => {
-      const project = opts.db.select({ name: projects.name }).from(projects).where(eq26(projects.id, projectId)).get();
+      const project = opts.db.select({ name: projects.name }).from(projects).where(eq29(projects.id, projectId)).get();
       if (!project) return;
       sessionRegistry.queueFollowUp(project.name, {
         role: "user",
@@ -17814,8 +18989,8 @@ async function createServer(opts) {
   );
   jobRunner.onRunCompleted = (runId, projectId) => runCoordinator.onRunCompleted(runId, projectId);
   const snapshotService = new SnapshotService(registry);
-  const orphanedOpenClawDir = path9.join(os5.homedir(), ".openclaw-aero");
-  if (fs8.existsSync(orphanedOpenClawDir)) {
+  const orphanedOpenClawDir = path15.join(os6.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."
@@ -17896,7 +19071,7 @@ async function createServer(opts) {
       return removed;
     }
   };
-  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto24.randomBytes(32).toString("hex");
+  const googleStateSecret = process.env.GOOGLE_STATE_SECRET ?? crypto27.randomBytes(32).toString("hex");
   const googleConnectionStore = {
     listConnections: (domain) => listGoogleConnections(opts.config, domain),
     getConnection: (domain, connectionType) => getGoogleConnection(opts.config, domain, connectionType),
@@ -17942,11 +19117,11 @@ async function createServer(opts) {
   const apiPrefix = basePath ? `${basePath}api/v1` : "/api/v1";
   if (opts.config.apiKey) {
     const keyHash = hashApiKey(opts.config.apiKey);
-    const existing = opts.db.select().from(apiKeys).where(eq26(apiKeys.keyHash, keyHash)).get();
+    const existing = opts.db.select().from(apiKeys).where(eq29(apiKeys.keyHash, keyHash)).get();
     if (!existing) {
       const prefix = opts.config.apiKey.slice(0, 12);
       opts.db.insert(apiKeys).values({
-        id: `key_${crypto24.randomBytes(8).toString("hex")}`,
+        id: `key_${crypto27.randomBytes(8).toString("hex")}`,
         name: "default",
         keyHash,
         keyPrefix: prefix,
@@ -17970,7 +19145,7 @@ async function createServer(opts) {
   };
   const createSession = (apiKeyId) => {
     pruneExpiredSessions();
-    const sessionId = crypto24.randomBytes(32).toString("hex");
+    const sessionId = crypto27.randomBytes(32).toString("hex");
     sessions.set(sessionId, {
       apiKeyId,
       expiresAt: Date.now() + SESSION_TTL_MS
@@ -17994,7 +19169,7 @@ async function createServer(opts) {
   };
   const getDefaultApiKey = () => {
     if (!opts.config.apiKey) return void 0;
-    return opts.db.select().from(apiKeys).where(eq26(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
+    return opts.db.select().from(apiKeys).where(eq29(apiKeys.keyHash, hashApiKey(opts.config.apiKey))).get();
   };
   const createPasswordSession = (reply) => {
     const key = getDefaultApiKey();
@@ -18051,12 +19226,12 @@ async function createServer(opts) {
       return reply.send({ authenticated: true });
     }
     if (apiKey) {
-      const key = opts.db.select().from(apiKeys).where(eq26(apiKeys.keyHash, hashApiKey(apiKey))).get();
+      const key = opts.db.select().from(apiKeys).where(eq29(apiKeys.keyHash, hashApiKey(apiKey))).get();
       if (!key || key.revokedAt) {
         const err2 = authInvalid();
         return reply.status(err2.statusCode).send(err2.toJSON());
       }
-      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq26(apiKeys.id, key.id)).run();
+      opts.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq29(apiKeys.id, key.id)).run();
       const sessionId = createSession(key.id);
       reply.header("set-cookie", serializeSessionCookie({
         name: SESSION_COOKIE_NAME,
@@ -18123,6 +19298,54 @@ async function createServer(opts) {
         app.log.error({ runId, err }, "Inspect sitemap failed");
       });
     },
+    getBacklinksStatus: () => ({
+      duckdbInstalled: isDuckdbInstalled(),
+      duckdbVersion: readInstalledVersion() ?? void 0,
+      duckdbSpec: DUCKDB_SPEC,
+      pluginDir: PLUGIN_DIR
+    }),
+    onInstallBacklinks: async () => {
+      const result = await installDuckdb({ onLog: (line) => app.log.info({ line }, "duckdb install") });
+      return {
+        installed: true,
+        version: result.version,
+        path: result.path,
+        alreadyPresent: result.alreadyPresent
+      };
+    },
+    onReleaseSyncRequested: (syncId, release) => {
+      executeReleaseSync(opts.db, syncId, { release }).catch((err) => {
+        app.log.error({ syncId, err }, "Common Crawl release sync failed");
+      });
+    },
+    onBacklinkExtractRequested: (runId, projectId, release) => {
+      executeBacklinkExtract(opts.db, runId, projectId, { release }).catch((err) => {
+        app.log.error({ runId, err }, "Backlink extract failed");
+      });
+    },
+    onBacklinksPruneCache: (release) => {
+      try {
+        pruneCachedRelease(release);
+      } catch (err) {
+        app.log.error({ release, err }, "Failed to prune cached release");
+      }
+    },
+    listCachedReleases: () => {
+      const cached = listCachedReleases();
+      const syncByRelease = /* @__PURE__ */ new Map();
+      for (const row of opts.db.select().from(ccReleaseSyncs).all()) {
+        syncByRelease.set(row.release, { status: row.status, updatedAt: row.updatedAt });
+      }
+      return cached.map((entry) => {
+        const sync = syncByRelease.get(entry.release);
+        return {
+          release: entry.release,
+          syncStatus: sync?.status ?? null,
+          bytes: entry.bytes,
+          lastUsedAt: entry.lastUsedAt
+        };
+      });
+    },
     openApiInfo: {
       title: "Canonry API",
       version: PKG_VERSION,
@@ -18203,7 +19426,7 @@ async function createServer(opts) {
         const targetProjectIds = affectedProjectIds.length > 0 ? affectedProjectIds : [null];
         const createdAt = (/* @__PURE__ */ new Date()).toISOString();
         opts.db.insert(auditLog).values(targetProjectIds.map((projectId) => ({
-          id: crypto24.randomUUID(),
+          id: crypto27.randomUUID(),
           projectId,
           actor: "api",
           action: existing ? "provider.updated" : "provider.created",
@@ -18334,10 +19557,10 @@ async function createServer(opts) {
       return snapshotService.createReport(input);
     }
   });
-  const dirname = path9.dirname(fileURLToPath2(import.meta.url));
-  const assetsDir = path9.join(dirname, "..", "assets");
-  if (fs8.existsSync(assetsDir)) {
-    const indexPath = path9.join(assetsDir, "index.html");
+  const dirname = path15.dirname(fileURLToPath2(import.meta.url));
+  const assetsDir = path15.join(dirname, "..", "assets");
+  if (fs12.existsSync(assetsDir)) {
+    const indexPath = path15.join(assetsDir, "index.html");
     const injectConfig = (html) => {
       const clientConfig = {};
       if (basePath) clientConfig.basePath = basePath;
@@ -18355,8 +19578,8 @@ async function createServer(opts) {
       index: false
     });
     const serveIndex = (_request, reply) => {
-      if (fs8.existsSync(indexPath)) {
-        const html = fs8.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" });
@@ -18376,8 +19599,8 @@ async function createServer(opts) {
       if (basePath && !url.startsWith(basePath)) {
         return reply.status(404).send({ error: "Not found", path: request.url });
       }
-      if (fs8.existsSync(indexPath)) {
-        const html = fs8.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" });