crawlemon 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,81 +1,190 @@
 // src/index.ts
-import fs3 from "node:fs";
-import path4 from "node:path";
+import fs6 from "node:fs";
+import os from "node:os";
+import path8 from "node:path";
 import { spawnSync } from "node:child_process";
 
 // ../next-adapter/src/parser.ts
-function parsePageSource(content) {
+function captured(match) {
+  if (!match) return void 0;
+  for (let index = 1; index < match.length; index += 1) {
+    const value = match[index];
+    if (value !== void 0 && value.trim() !== "") return value.trim();
+  }
+  return void 0;
+}
+function earliest(content, patterns) {
+  let best;
+  for (const pattern of patterns) {
+    const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    for (const match of content.matchAll(globalPattern)) {
+      const value = captured(match);
+      if (value !== void 0) {
+        if (best === void 0 || match.index < best.index) best = { value, index: match.index };
+        break;
+      }
+    }
+  }
+  return best?.value;
+}
+function parseFrontmatter(content) {
+  const fence = content.match(/^(?:\uFEFF)?[\s]*?---\s*\n([\s\S]*?)\n---\s*\n/);
+  if (!fence) return null;
+  const fields = {};
+  for (const line of fence[1].split("\n")) {
+    const clean = line.replace(/#.*$/, "").trim();
+    if (!clean) continue;
+    const match = clean.match(/^([A-Za-z][\w-]*)\s*:\s*(.+)$/);
+    if (!match) continue;
+    const key = match[1].toLowerCase();
+    const raw = match[2].trim();
+    if (!raw.startsWith('"') && !raw.startsWith("'")) continue;
+    const value = raw.replace(/^(['"])([\s\S]*)\1$/, "$2").trim();
+    if (!value) continue;
+    if (key === "title") fields.title = value;
+    else if (key === "description") fields.description = value;
+    else if (key === "canonical") fields.canonical = value;
+    else if (key === "robots") fields.robots = value;
+  }
+  return { fields, index: 0 };
+}
+var TITLE_PATTERNS = [
+  // HTML <title> block (SvelteKit <svelte:head>, Astro, static HTML, JSX)
+  /<title[^>]*>([^<]+)<\/title>/i,
+  // Object default (Next.js metadata title: { default: '...', template })
+  /\btitle\s*:\s*\{[^{}]*\bdefault\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/,
+  // Literal config (Next.js metadata, Nuxt useHead/definePageMeta, Remix meta)
+  /\btitle\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/
+];
+var DESCRIPTION_PATTERNS = [
+  // HTML meta description
+  /<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["']/i,
+  /<meta[^>]*content=["']([^"']+)["'][^>]*name=["']description["']/i,
+  // meta array item (Nuxt useHead meta, Remix meta function)
+  /name\s*:\s*["']description["']\s*,\s*content\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/,
+  // Literal config (Next.js metadata object)
+  /\bdescription\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/
+];
+var CANONICAL_PATTERNS = [
+  // HTML <link rel="canonical">
+  /<link[^>]*rel=["']canonical["'][^>]*href=(?:"([^"]+)"|'([^']+)')/i,
+  /<link[^>]*href=(?:"([^"]+)"|'([^']+)')[^>]*rel=["']canonical["']/i,
+  // link array item (Nuxt useHead link, Remix meta)
+  /rel\s*:\s*["']canonical["']\s*,\s*href\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/,
+  // Literal config (Next.js metadata alternates.canonical)
+  /\bcanonical\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/
+];
+var ROBOTS_PATTERNS = [
+  // HTML meta robots
+  /<meta[^>]*name=["']robots["'][^>]*content=["']([^"']+)["']/i,
+  // Literal config (Next.js metadata robots string)
+  /\brobots\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/
+];
+function hasConflictingDeclarations(content, framework) {
+  if (framework === "nextjs") {
+    const mechanisms = [
+      /export\s+const\s+metadata\b/.test(content),
+      /export\s+(?:async\s+)?function\s+generateMetadata\b/.test(content),
+      /<Head\b/.test(content)
+    ].filter(Boolean).length;
+    return mechanisms > 1;
+  }
+  if (framework === "nuxt") {
+    const mechanisms = [
+      /\buseHead\s*\(/.test(content),
+      /\bdefinePageMeta\s*\(/.test(content),
+      /<Head\b/.test(content)
+    ].filter(Boolean).length;
+    return mechanisms > 1;
+  }
+  return false;
+}
+var IMAGE_TAGS = ["img", "Image", "NuxtImg"];
+function lineAt(content, index) {
+  return content.slice(0, index).split("\n").length;
+}
+function stripTemplate(text) {
+  return text.replace(/<[^>]+>/g, "").replace(/\{\{[\s\S]*?\}\}/g, " ").replace(/\{[^{}]*\}/g, " ").trim();
+}
+function parsePageSource(content, framework = "nextjs") {
   const metadata = {};
   const headings = [];
   const images = [];
   const links = [];
-  const lineAt = (index) => content.slice(0, index).split("\n").length;
-  const titleMatch = content.match(/title\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/title\s*:\s*\{[\s\S]*?default\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<title[^>]*>([^<]+)<\/title>/i);
-  if (titleMatch) {
-    metadata.title = titleMatch[1].trim();
-  }
-  const descMatch = content.match(/description\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["']/i) || content.match(/<meta[^>]*content=["']([^"']+)["'][^>]*name=["']description["']/i);
-  if (descMatch) {
-    metadata.description = descMatch[1].trim();
-  }
-  const canonicalMatch = content.match(/canonical\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<link[^>]*rel=["']canonical["'][^>]*href=["']([^"']+)["']/i);
-  if (canonicalMatch) {
-    metadata.canonical = canonicalMatch[1].trim();
+  const frontmatter = parseFrontmatter(content);
+  const title = earliest(content, TITLE_PATTERNS);
+  const description = earliest(content, DESCRIPTION_PATTERNS);
+  const canonical = earliest(content, CANONICAL_PATTERNS);
+  const robots = earliest(content, ROBOTS_PATTERNS);
+  if (title !== void 0) metadata.title = title;
+  if (description !== void 0) metadata.description = description;
+  if (canonical !== void 0) metadata.canonical = canonical;
+  if (robots !== void 0) metadata.robots = robots;
+  if (frontmatter) {
+    if (metadata.title === void 0 && frontmatter.fields.title !== void 0) metadata.title = frontmatter.fields.title;
+    if (metadata.description === void 0 && frontmatter.fields.description !== void 0) {
+      metadata.description = frontmatter.fields.description;
+    }
+    if (metadata.canonical === void 0 && frontmatter.fields.canonical !== void 0) {
+      metadata.canonical = frontmatter.fields.canonical;
+    }
+    if (metadata.robots === void 0 && frontmatter.fields.robots !== void 0) {
+      metadata.robots = frontmatter.fields.robots;
+    }
   }
-  const robotsMatch = content.match(/robots\s*:\s*["'`]([^"'`]+)["'`]/) || content.match(/<meta[^>]*name=["']robots["'][^>]*content=["']([^"']+)["']/i);
-  if (robotsMatch) {
-    metadata.robots = robotsMatch[1].trim();
+  const robotsObjectMatch = content.match(/\brobots\s*:\s*\{[^{}]*\b(noindex|index)\b[^{}]*\}/);
+  if (metadata.robots === void 0 && robotsObjectMatch) {
+    const mode = robotsObjectMatch[1];
+    metadata.robots = mode === "noindex" || robotsObjectMatch[0].includes("index: false") ? "noindex" : "";
   }
-  const jsonLdMatches = content.matchAll(/<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi);
   const jsonLd = [];
-  for (const match of jsonLdMatches) {
+  for (const match of content.matchAll(/<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)) {
     try {
-      const parsed = JSON.parse(match[1].trim());
-      jsonLd.push(parsed);
+      jsonLd.push(JSON.parse(match[1].trim()));
     } catch {
       jsonLd.push({ invalid: true });
     }
   }
-  if (jsonLd.length > 0) {
-    metadata.jsonLd = jsonLd;
-  }
-  const declarationCount = [
-    /export\s+const\s+metadata\b/.test(content),
-    /export\s+(?:async\s+)?function\s+generateMetadata\b/.test(content),
-    /<Head\b/.test(content)
-  ].filter(Boolean).length;
-  metadata.hasConflictingDeclarations = declarationCount > 1;
+  if (jsonLd.length > 0) metadata.jsonLd = jsonLd;
+  metadata.hasConflictingDeclarations = hasConflictingDeclarations(content, framework);
   for (const match of content.matchAll(/<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi)) {
     headings.push({
       level: parseInt(match[1], 10),
-      text: match[2].replace(/<[^>]+>/g, "").replace(/[{}]/g, "").trim(),
-      line: lineAt(match.index || 0)
+      text: stripTemplate(match[2]),
+      line: lineAt(content, match.index || 0)
     });
   }
-  for (const match of content.matchAll(/<(img|Image)\b([^>]*?)\/?>/g)) {
-    const attrs = match[2];
-    const srcMatch = attrs.match(/src\s*=\s*["'`]([^"'`]+)["'`]/);
-    const altMatch = attrs.match(/alt\s*=\s*["'`]([^"'`]*?)["'`]/);
-    images.push({
-      src: srcMatch ? srcMatch[1] : "unknown-image",
-      alt: altMatch ? altMatch[1] : void 0,
-      isNextImage: match[1] === "Image",
-      line: lineAt(match.index || 0)
-    });
+  for (const tag of IMAGE_TAGS) {
+    const re = new RegExp(`<(${tag})\\b([^>]*?)\\/?>`, "gi");
+    for (const match of content.matchAll(re)) {
+      const attrs = match[2];
+      const srcMatch = attrs.match(/\bsrc\s*=\s*["'`]([^"'`]+)["'`]/);
+      const altMatch = attrs.match(/\balt\s*=\s*["'`]([^"'`]*?)["'`]/);
+      if (!srcMatch && !altMatch) continue;
+      images.push({
+        src: srcMatch ? srcMatch[1] : "unknown-image",
+        alt: altMatch ? altMatch[1] : void 0,
+        isNextImage: tag !== "img",
+        line: lineAt(content, match.index || 0)
+      });
+    }
   }
-  for (const match of content.matchAll(/<(a|Link)\b[^>]*?href\s*=\s*["']([^"']+)["'][^>]*>([\s\S]*?)<\/\1>/g)) {
-    const href = match[2].trim();
-    const anchorRaw = match[3].replace(/<[^>]+>/g, "").replace(/[{}]/g, "").trim();
+  const LINK_RE = /<(a|Link|NuxtLink|RouterLink|router-link)\b([^>]*?)(?:href|to)\s*=\s*(?:"([^"]+)"|'([^']+)')([^>]*)>([\s\S]*?)<\/\1>/gi;
+  for (const match of content.matchAll(LINK_RE)) {
+    const href = (match[3] ?? match[4])?.trim();
+    if (href === void 0 || href === "") continue;
+    const anchorRaw = stripTemplate(match[6]);
     const isInternal = href.startsWith("/") || !/^(https?:|mailto:|tel:|javascript:)/i.test(href);
     links.push({
       href,
       anchorText: anchorRaw || "(empty anchor)",
-      line: lineAt(match.index || 0),
+      line: lineAt(content, match.index || 0),
       isInternal
     });
   }
-  const cleanBodyText = content.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-  const words = cleanBodyText.split(/\s+/).filter((w) => w.length > 2);
+  const cleanBodyText = content.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\{\{[\s\S]*?\}\}/g, " ").replace(/\{[^{}]*\}/g, " ").replace(/\s+/g, " ").trim();
+  const words = cleanBodyText.split(/\s+/).filter((word) => word.length > 2);
   const hasLittleContent = words.length < 20;
   return {
     metadata,
@@ -88,8 +197,184 @@ function parsePageSource(content) {
 }
 
 // ../next-adapter/src/scanner.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// ../next-adapter/src/dependency-graph.ts
 import fs from "node:fs";
 import path from "node:path";
+var RouteDependencyGraph = class {
+  projectRoot;
+  appDir;
+  layoutsByDir = /* @__PURE__ */ new Map();
+  routes = [];
+  constructor(projectRoot, appDir) {
+    this.projectRoot = projectRoot;
+    this.appDir = appDir;
+  }
+  indexLayouts() {
+    this.layoutsByDir.clear();
+    if (!fs.existsSync(this.appDir)) return;
+    const walkDir = (currentDir) => {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          if (!entry.name.startsWith(".") && entry.name !== "node_modules" && entry.name !== "api") {
+            walkDir(fullPath);
+          }
+        } else if (entry.isFile() && /^layout\.(tsx|jsx|js|ts)$/.test(entry.name)) {
+          const content = fs.readFileSync(fullPath, "utf8");
+          const parsed = parsePageSource(content, "nextjs");
+          const relativeDir = path.relative(this.appDir, currentDir);
+          let canonicalLine;
+          let robotsLine;
+          let titleLine;
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.includes("canonical")) canonicalLine = i + 1;
+            if (line.includes("robots")) robotsLine = i + 1;
+            if (line.includes("title")) titleLine = i + 1;
+          }
+          this.layoutsByDir.set(relativeDir, {
+            filePath: fullPath,
+            relativeDir,
+            metadata: parsed.metadata,
+            metadataSourceLocation: {
+              canonicalLine,
+              robotsLine,
+              titleLine
+            }
+          });
+        }
+      }
+    };
+    walkDir(this.appDir);
+  }
+  setRoutes(routes) {
+    this.routes = routes;
+  }
+  /**
+   * Resolves merged inherited metadata for a given route based on all parent layouts.
+   */
+  getInheritedMetadata(routeFilePath) {
+    const routeDir = path.dirname(routeFilePath);
+    let relativeDir = path.relative(this.appDir, routeDir);
+    const merged = {};
+    const chain = [];
+    while (true) {
+      const layout = this.layoutsByDir.get(relativeDir);
+      if (layout) {
+        chain.unshift(layout);
+      }
+      if (relativeDir === "" || relativeDir === ".") break;
+      relativeDir = path.dirname(relativeDir);
+      if (relativeDir === ".") relativeDir = "";
+    }
+    for (const layout of chain) {
+      Object.assign(merged, layout.metadata);
+    }
+    return merged;
+  }
+  /**
+   * Calculates the blast radius (affected routes) when a layout or component file is modified.
+   */
+  calculateBlastRadius(modifiedFilePath) {
+    const relative = path.relative(this.appDir, modifiedFilePath).replace(/\\/g, "/");
+    const layoutDir = path.dirname(relative) === "." ? "" : path.dirname(relative);
+    const affected = this.routes.filter((route) => {
+      const routeRel = path.relative(this.appDir, route.filePath).replace(/\\/g, "/");
+      if (layoutDir === "") return true;
+      return routeRel.startsWith(layoutDir + "/");
+    });
+    const routePattern = layoutDir === "" ? "/*" : `/${layoutDir.replace(/\/\([^)]+\)/g, "")}/*`;
+    const hasDynamic = routePattern.includes("[");
+    return {
+      sourceFile: modifiedFilePath,
+      routePattern,
+      affectedRoutes: affected.map((r) => r.route),
+      confidence: hasDynamic ? "ROUTE_PATTERN" : "KNOWN_ROUTES"
+    };
+  }
+  /**
+   * Returns all indexed layouts.
+   */
+  getLayouts() {
+    return Array.from(this.layoutsByDir.values());
+  }
+  /**
+   * Returns a unified SEODependencyGraph representation for Next.js app router.
+   */
+  toSEODependencyGraph(linkGraph) {
+    const nodes = [];
+    const edges = [];
+    for (const layout of this.layoutsByDir.values()) {
+      const layoutId = `layout:${layout.filePath}`;
+      nodes.push({
+        id: layoutId,
+        type: "layout",
+        label: layout.filePath,
+        path: layout.filePath,
+        metadata: layout.metadata
+      });
+    }
+    for (const route of this.routes) {
+      const routeId = `route:${route.route}`;
+      nodes.push({
+        id: routeId,
+        type: "route",
+        label: route.route,
+        path: route.filePath,
+        metadata: route.metadata
+      });
+      if (route.filePath) {
+        const fileId = `file:${route.filePath}`;
+        nodes.push({
+          id: fileId,
+          type: "source_file",
+          label: route.filePath,
+          path: route.filePath
+        });
+        edges.push({
+          source: fileId,
+          target: routeId,
+          type: "DEFINES_METADATA",
+          detail: "route entrypoint"
+        });
+      }
+      const routeDir = path.dirname(route.filePath);
+      let relativeDir = path.relative(this.appDir, routeDir).replace(/\\/g, "/");
+      while (true) {
+        const layout = this.layoutsByDir.get(relativeDir);
+        if (layout) {
+          edges.push({
+            source: routeId,
+            target: `layout:${layout.filePath}`,
+            type: "INHERITS_FROM",
+            detail: "layout metadata inheritance"
+          });
+        }
+        if (relativeDir === "" || relativeDir === ".") break;
+        const parent = path.dirname(relativeDir);
+        relativeDir = parent === "." ? "" : parent;
+      }
+    }
+    if (linkGraph?.edges) {
+      for (const link of linkGraph.edges) {
+        edges.push({
+          source: `route:${link.source}`,
+          target: `route:${link.target}`,
+          type: "LINKS_TO",
+          detail: link.anchorText
+        });
+      }
+    }
+    return { nodes, edges };
+  }
+};
+
+// ../next-adapter/src/scanner.ts
 function normalizeRouteGroup(segment) {
   return segment.startsWith("(") && segment.endsWith(")") ? "" : segment;
 }
@@ -98,33 +383,39 @@ var NextJsAdapter = class {
    * Detects if the given directory contains a Next.js application.
    */
   static async detect(projectRoot) {
-    const pkgPath = path.join(projectRoot, "package.json");
-    if (fs.existsSync(pkgPath)) {
+    const pkgPath = path2.join(projectRoot, "package.json");
+    if (fs2.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
         const deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
         if (deps.next) return true;
       } catch {
       }
     }
-    return fs.existsSync(path.join(projectRoot, "app")) || fs.existsSync(path.join(projectRoot, "src", "app")) || fs.existsSync(path.join(projectRoot, "pages")) || fs.existsSync(path.join(projectRoot, "src", "pages")) || fs.existsSync(path.join(projectRoot, "next.config.js")) || fs.existsSync(path.join(projectRoot, "next.config.mjs"));
+    return fs2.existsSync(path2.join(projectRoot, "app")) || fs2.existsSync(path2.join(projectRoot, "src", "app")) || fs2.existsSync(path2.join(projectRoot, "pages")) || fs2.existsSync(path2.join(projectRoot, "src", "pages")) || fs2.existsSync(path2.join(projectRoot, "next.config.js")) || fs2.existsSync(path2.join(projectRoot, "next.config.mjs"));
   }
   /**
    * Loads optional seo.config.ts or returns default configuration.
    */
   static async loadConfig(projectRoot) {
     const configCandidates = [
-      path.join(projectRoot, "seo.config.ts"),
-      path.join(projectRoot, "seo.config.js"),
-      path.join(projectRoot, "seo.config.json")
+      path2.join(projectRoot, "crawlemon.config.ts"),
+      path2.join(projectRoot, "crawlemon.config.js"),
+      path2.join(projectRoot, "crawlemon.config.mjs"),
+      path2.join(projectRoot, "crawlemon.config.json"),
+      path2.join(projectRoot, "crawlemon.yml"),
+      path2.join(projectRoot, "crawlemon.yaml"),
+      path2.join(projectRoot, "seo.config.ts"),
+      path2.join(projectRoot, "seo.config.js"),
+      path2.join(projectRoot, "seo.config.json")
     ];
     for (const candidate of configCandidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs2.existsSync(candidate)) {
         try {
           if (candidate.endsWith(".json")) {
-            return JSON.parse(fs.readFileSync(candidate, "utf8"));
+            return JSON.parse(fs2.readFileSync(candidate, "utf8"));
           }
-          const content = fs.readFileSync(candidate, "utf8");
+          const content = fs2.readFileSync(candidate, "utf8");
           const siteUrlMatch = content.match(/siteUrl\s*:\s*["']([^"']+)["']/);
           const ignoreMatch = content.match(/ignore\s*:\s*\[([\s\S]*?)\]/);
           const ignore = ignoreMatch ? Array.from(ignoreMatch[1].matchAll(/["']([^"']+)["']/g), (match) => match[1]) : void 0;
@@ -135,6 +426,23 @@ var NextJsAdapter = class {
               rules[match[1]] = match[2] === "true";
             }
           }
+          const exportMatch = content.match(/export\s+default\s+([\s\S]+?);?$/);
+          if (exportMatch) {
+            try {
+              const evaluated = new Function(`return (${exportMatch[1].trim()})`)();
+              if (evaluated && typeof evaluated === "object") {
+                return {
+                  siteUrl: evaluated.siteUrl || siteUrlMatch?.[1],
+                  ignore: evaluated.ignore || ignore,
+                  rules: evaluated.rules || rules,
+                  qualityGate: evaluated.qualityGate,
+                  contracts: evaluated.contracts,
+                  opportunityKeywords: evaluated.opportunityKeywords
+                };
+              }
+            } catch {
+            }
+          }
           return {
             siteUrl: siteUrlMatch ? siteUrlMatch[1] : void 0,
             ignore,
@@ -155,64 +463,53 @@ var NextJsAdapter = class {
   static async scan(projectRoot) {
     const isNext = await this.detect(projectRoot);
     const config = await this.loadConfig(projectRoot);
-    let appDir = path.join(projectRoot, "app");
-    if (!fs.existsSync(appDir) && fs.existsSync(path.join(projectRoot, "src", "app"))) {
-      appDir = path.join(projectRoot, "src", "app");
+    let appDir = path2.join(projectRoot, "app");
+    if (!fs2.existsSync(appDir) && fs2.existsSync(path2.join(projectRoot, "src", "app"))) {
+      appDir = path2.join(projectRoot, "src", "app");
     }
-    let pagesDir = path.join(projectRoot, "pages");
-    if (!fs.existsSync(pagesDir) && fs.existsSync(path.join(projectRoot, "src", "pages"))) {
-      pagesDir = path.join(projectRoot, "src", "pages");
+    let pagesDir = path2.join(projectRoot, "pages");
+    if (!fs2.existsSync(pagesDir) && fs2.existsSync(path2.join(projectRoot, "src", "pages"))) {
+      pagesDir = path2.join(projectRoot, "src", "pages");
     }
-    const isAppRouter = fs.existsSync(appDir);
+    const isAppRouter = fs2.existsSync(appDir);
     const routes = [];
     const redirects = [];
     for (const configName of ["next.config.js", "next.config.mjs", "next.config.ts"]) {
-      const configPath = path.join(projectRoot, configName);
-      if (!fs.existsSync(configPath)) continue;
-      const content = fs.readFileSync(configPath, "utf8");
+      const configPath = path2.join(projectRoot, configName);
+      if (!fs2.existsSync(configPath)) continue;
+      const content = fs2.readFileSync(configPath, "utf8");
       for (const match of content.matchAll(/source\s*:\s*["'`]([^"'`]+)["'`][\s\S]{0,500}?destination\s*:\s*["'`]([^"'`]+)["'`][\s\S]{0,200}?permanent\s*:\s*(true|false)/g)) {
         redirects.push({ source: match[1], destination: match[2], permanent: match[3] === "true" });
       }
       break;
     }
-    let rootLayoutMetadata = {};
-    if (isAppRouter) {
-      const layoutFileCandidates = [
-        path.join(appDir, "layout.tsx"),
-        path.join(appDir, "layout.jsx"),
-        path.join(appDir, "layout.js")
-      ];
-      for (const layoutFile of layoutFileCandidates) {
-        if (fs.existsSync(layoutFile)) {
-          const content = fs.readFileSync(layoutFile, "utf8");
-          const parsed = parsePageSource(content);
-          rootLayoutMetadata = parsed.metadata;
-          break;
-        }
-      }
+    const dependencyGraph = isAppRouter ? new RouteDependencyGraph(projectRoot, appDir) : void 0;
+    if (dependencyGraph) {
+      dependencyGraph.indexLayouts();
     }
     if (isAppRouter) {
       const scanAppDir = (currentDir, relativePath = "") => {
-        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path.join(currentDir, entry.name);
+          const fullPath = path2.join(currentDir, entry.name);
           if (entry.isDirectory()) {
             if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "api") {
               continue;
             }
             const normalized = normalizeRouteGroup(entry.name);
-            const nextRelative = normalized ? path.join(relativePath, normalized) : relativePath;
+            const nextRelative = normalized ? path2.join(relativePath, normalized) : relativePath;
             scanAppDir(fullPath, nextRelative);
           } else if (entry.isFile()) {
             if (/^page\.(tsx|jsx|js|ts)$/.test(entry.name)) {
               const routePath = relativePath === "" ? "/" : `/${relativePath.replace(/\\/g, "/")}`;
-              const content = fs.readFileSync(fullPath, "utf8");
+              const content = fs2.readFileSync(fullPath, "utf8");
               const parsed = parsePageSource(content);
+              const inheritedMetadata = dependencyGraph ? dependencyGraph.getInheritedMetadata(fullPath) : {};
               routes.push({
                 route: routePath,
                 filePath: fullPath,
                 metadata: {
-                  ...rootLayoutMetadata,
+                  ...inheritedMetadata,
                   ...parsed.metadata
                 },
                 headings: parsed.headings,
@@ -228,25 +525,25 @@ var NextJsAdapter = class {
       };
       scanAppDir(appDir);
     }
-    if (fs.existsSync(pagesDir)) {
+    if (fs2.existsSync(pagesDir)) {
       const scanPagesDir = (currentDir, relativePath = "") => {
-        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        const entries = fs2.readdirSync(currentDir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path.join(currentDir, entry.name);
+          const fullPath = path2.join(currentDir, entry.name);
           if (entry.isDirectory()) {
             if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "api") {
               continue;
             }
-            scanPagesDir(fullPath, path.join(relativePath, entry.name));
+            scanPagesDir(fullPath, path2.join(relativePath, entry.name));
           } else if (entry.isFile()) {
             if (/\.(tsx|jsx|js)$/.test(entry.name)) {
               const baseName = entry.name.replace(/\.(tsx|jsx|js)$/, "");
               if (baseName.startsWith("_") || baseName === "api") {
                 continue;
               }
-              let routePath = `/${path.join(relativePath, baseName === "index" ? "" : baseName).replace(/\\/g, "/")}`;
+              let routePath = `/${path2.join(relativePath, baseName === "index" ? "" : baseName).replace(/\\/g, "/")}`;
               if (routePath === "//" || routePath === "") routePath = "/";
-              const content = fs.readFileSync(fullPath, "utf8");
+              const content = fs2.readFileSync(fullPath, "utf8");
               const parsed = parsePageSource(content);
               routes.push({
                 route: routePath,
@@ -266,17 +563,17 @@ var NextJsAdapter = class {
       scanPagesDir(pagesDir);
     }
     const sitemapCandidates = [
-      path.join(appDir, "sitemap.ts"),
-      path.join(appDir, "sitemap.js"),
-      path.join(projectRoot, "public", "sitemap.xml")
+      path2.join(appDir, "sitemap.ts"),
+      path2.join(appDir, "sitemap.js"),
+      path2.join(projectRoot, "public", "sitemap.xml")
     ];
     let sitemapFound = false;
     let sitemapMalformed = false;
     const sitemapUrls = [];
     for (const candidate of sitemapCandidates) {
-      if (fs.existsSync(candidate)) {
+      if (fs2.existsSync(candidate)) {
         sitemapFound = true;
-        const content = fs.readFileSync(candidate, "utf8");
+        const content = fs2.readFileSync(candidate, "utf8");
         if (candidate.endsWith(".xml") && (!/<urlset\b/i.test(content) || !/<loc>[^<]+<\/loc>/i.test(content))) {
           sitemapMalformed = true;
         }
@@ -289,14 +586,17 @@ var NextJsAdapter = class {
       }
     }
     const robotsCandidates = [
-      path.join(appDir, "robots.ts"),
-      path.join(appDir, "robots.js"),
-      path.join(projectRoot, "public", "robots.txt")
+      path2.join(appDir, "robots.ts"),
+      path2.join(appDir, "robots.js"),
+      path2.join(projectRoot, "public", "robots.txt")
     ];
-    const robotsFile = robotsCandidates.find((candidate) => fs.existsSync(candidate));
+    const robotsFile = robotsCandidates.find((candidate) => fs2.existsSync(candidate));
     const robotsFound = Boolean(robotsFile);
-    const robotsContent = robotsFile ? fs.readFileSync(robotsFile, "utf8") : "";
+    const robotsContent = robotsFile ? fs2.readFileSync(robotsFile, "utf8") : "";
     routes.sort((a, b) => a.route.localeCompare(b.route));
+    if (dependencyGraph) {
+      dependencyGraph.setRoutes(routes);
+    }
     return {
       isNextJs: isNext,
       isAppRouter,
@@ -308,7 +608,175 @@ var NextJsAdapter = class {
       robotsContent,
       redirects,
       config,
-      projectRoot
+      projectRoot,
+      dependencyGraph
+    };
+  }
+};
+
+// ../next-adapter/src/framework-adapter.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+var INHERITED_METADATA_FIELDS = ["title", "description", "canonical", "robots"];
+var LABELS = {
+  nextjs: "Next.js",
+  nuxt: "Nuxt",
+  sveltekit: "SvelteKit",
+  astro: "Astro",
+  remix: "Remix",
+  vite: "Vite",
+  static: "Static HTML"
+};
+function dependencies(root) {
+  try {
+    const pkg = JSON.parse(fs3.readFileSync(path3.join(root, "package.json"), "utf8"));
+    return { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+  } catch {
+    return {};
+  }
+}
+function walk(dir, visit) {
+  if (!fs3.existsSync(dir)) return;
+  for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || ["node_modules", "dist", "build", ".output"].includes(entry.name)) continue;
+    const full = path3.join(dir, entry.name);
+    if (entry.isDirectory()) walk(full, visit);
+    else if (entry.isFile()) visit(full);
+  }
+}
+function routeNode(file, route, framework) {
+  const parsed = parsePageSource(fs3.readFileSync(file, "utf8"), framework);
+  return { route, filePath: file, ...parsed, hasDynamicSegments: /[:[*]/.test(route) };
+}
+function cleanRoute(value) {
+  let route = `/${value}`.replace(/\\/g, "/").replace(/\/+/g, "/");
+  route = route.replace(/\/(index|\+page)$/i, "").replace(/\/\([^/]+\)/g, "");
+  return route === "" ? "/" : route;
+}
+function discoverRoutes(root, framework) {
+  const routes = [];
+  const add = (base, extensions, convert) => {
+    walk(base, (file) => {
+      const relative = path3.relative(base, file);
+      if (!extensions.test(relative) || /(^|\/)api(\/|\.|$)/.test(relative)) return;
+      routes.push(routeNode(file, convert(relative), framework));
+    });
+  };
+  if (framework === "nuxt") {
+    const base = fs3.existsSync(path3.join(root, "pages")) ? path3.join(root, "pages") : path3.join(root, "app", "pages");
+    add(base, /\.vue$/, (r) => cleanRoute(r.replace(/\.vue$/, "").replace(/\[\.\.\.([^\]]+)\]/g, "*$1").replace(/\[([^\]]+)\]/g, ":$1")));
+  } else if (framework === "sveltekit") {
+    const base = path3.join(root, "src", "routes");
+    add(base, /(^|\/)\+page\.svelte$/, (r) => cleanRoute(r.replace(/\/\+page\.svelte$/, "").replace(/^\+page\.svelte$/, "")));
+  } else if (framework === "astro") {
+    const base = path3.join(root, "src", "pages");
+    add(base, /\.(astro|md|mdx)$/, (r) => cleanRoute(r.replace(/\.(astro|md|mdx)$/, "")));
+  } else if (framework === "remix") {
+    const base = path3.join(root, "app", "routes");
+    add(base, /\.(tsx|jsx|ts|js)$/, (r) => cleanRoute(r.replace(/\.(tsx|jsx|ts|js)$/, "").replace(/\._index$/, "").replace(/^_index$/, "").replace(/\./g, "/").replace(/\$([^/]+)/g, ":$1")));
+  } else if (framework === "vite") {
+    for (const candidate of ["src/App.tsx", "src/App.jsx", "src/App.vue", "src/App.svelte", "index.html"]) {
+      const file = path3.join(root, candidate);
+      if (fs3.existsSync(file)) routes.push(routeNode(file, "/", framework));
+    }
+  } else {
+    add(root, /\.html?$/, (r) => cleanRoute(r.replace(/\.html?$/, "")));
+  }
+  const unique = new Map(routes.map((route) => [route.route, route]));
+  return [...unique.values()].sort((a, b) => a.route.localeCompare(b.route));
+}
+function svelteKitLayouts(root) {
+  const layoutByDir = /* @__PURE__ */ new Map();
+  const base = path3.join(root, "src", "routes");
+  const readLayout = (dir) => {
+    const layoutFile = path3.join(dir, "+layout.svelte");
+    if (fs3.existsSync(layoutFile)) {
+      layoutByDir.set(dir, parsePageSource(fs3.readFileSync(layoutFile, "utf8"), "sveltekit").metadata);
+    }
+    for (const entry of fs3.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        readLayout(path3.join(dir, entry.name));
+      }
+    }
+  };
+  if (fs3.existsSync(base)) readLayout(base);
+  return layoutByDir;
+}
+function mergeLayoutMetadata(routes, framework, root) {
+  if (framework !== "sveltekit") return routes;
+  const layoutByDir = svelteKitLayouts(root);
+  if (layoutByDir.size === 0) return routes;
+  const base = path3.join(root, "src", "routes");
+  return routes.map((route) => {
+    const merged = {};
+    let dir = path3.dirname(route.filePath);
+    while (dir === base || dir.startsWith(`${base}${path3.sep}`)) {
+      const meta = layoutByDir.get(dir);
+      if (meta) {
+        for (const field of INHERITED_METADATA_FIELDS) {
+          if (merged[field] === void 0 && meta[field] !== void 0) merged[field] = meta[field];
+        }
+      }
+      if (dir === base) break;
+      dir = path3.dirname(dir);
+    }
+    if (Object.keys(merged).length === 0) return route;
+    for (const field of INHERITED_METADATA_FIELDS) {
+      if (route.metadata[field] !== void 0) merged[field] = route.metadata[field];
+    }
+    return { ...route, metadata: { ...route.metadata, ...merged } };
+  });
+}
+function crawlFiles(root) {
+  const roots = [path3.join(root, "public"), path3.join(root, "static"), root];
+  const sitemap = roots.map((dir) => path3.join(dir, "sitemap.xml")).find(fs3.existsSync);
+  const robots = roots.map((dir) => path3.join(dir, "robots.txt")).find(fs3.existsSync);
+  const sitemapContent = sitemap ? fs3.readFileSync(sitemap, "utf8") : "";
+  return {
+    sitemapFound: Boolean(sitemap),
+    sitemapUrls: [...sitemapContent.matchAll(/<loc>([^<]+)<\/loc>/gi)].map((m) => m[1].trim()),
+    sitemapMalformed: Boolean(sitemap && (!/<urlset\b/i.test(sitemapContent) || !/<loc>[^<]+<\/loc>/i.test(sitemapContent))),
+    robotsFound: Boolean(robots),
+    robotsContent: robots ? fs3.readFileSync(robots, "utf8") : ""
+  };
+}
+var FrameworkAdapter = class {
+  static async detect(root) {
+    const deps = dependencies(root);
+    if (deps.next) return "nextjs";
+    if (deps.nuxt) return "nuxt";
+    if (deps["@sveltejs/kit"]) return "sveltekit";
+    if (deps.astro) return "astro";
+    if (deps["@remix-run/react"] || deps["@remix-run/node"]) return "remix";
+    if (deps.vite) return "vite";
+    if (await NextJsAdapter.detect(root)) return "nextjs";
+    if (fs3.existsSync(path3.join(root, "nuxt.config.ts")) || fs3.existsSync(path3.join(root, "nuxt.config.js"))) return "nuxt";
+    if (fs3.existsSync(path3.join(root, "svelte.config.js")) && fs3.existsSync(path3.join(root, "src", "routes"))) {
+      return "sveltekit";
+    }
+    if (fs3.existsSync(path3.join(root, "index.html"))) return "static";
+    return null;
+  }
+  static async scan(root) {
+    const framework = await this.detect(root);
+    if (!framework) throw new Error(`No supported web framework detected in "${root}".`);
+    if (framework === "nextjs") {
+      const scan = await NextJsAdapter.scan(root);
+      return { ...scan, framework, frameworkLabel: LABELS[framework] };
+    }
+    const routes = mergeLayoutMetadata(discoverRoutes(root, framework), framework, root);
+    const config = await NextJsAdapter.loadConfig(root);
+    const redirects = [];
+    return {
+      framework,
+      frameworkLabel: LABELS[framework],
+      isNextJs: false,
+      isAppRouter: false,
+      routes,
+      redirects,
+      config,
+      projectRoot: root,
+      ...crawlFiles(root)
     };
   }
 };
@@ -717,9 +1185,9 @@ var linksRule = {
   analyze(context) {
     const findings = [];
     const validRoutes = new Set(context.routes.map((r) => r.route));
-    const normalizeRoute = (r) => r.endsWith("/") && r.length > 1 ? r.slice(0, -1) : r;
-    const normalizedValidRoutes = new Set([...validRoutes].map(normalizeRoute));
-    const redirects = new Map((context.redirects || []).map((redirect) => [normalizeRoute(redirect.source), redirect.destination]));
+    const normalizeRoute2 = (r) => r.endsWith("/") && r.length > 1 ? r.slice(0, -1) : r;
+    const normalizedValidRoutes = new Set([...validRoutes].map(normalizeRoute2));
+    const redirects = new Map((context.redirects || []).map((redirect) => [normalizeRoute2(redirect.source), redirect.destination]));
     for (const route of context.routes) {
       for (const link of route.links) {
         if (!link.isInternal) continue;
@@ -739,7 +1207,7 @@ var linksRule = {
           });
           continue;
         }
-        const cleanHref = normalizeRoute(href.split("?")[0].split("#")[0]);
+        const cleanHref = normalizeRoute2(href.split("?")[0].split("#")[0]);
         if (cleanHref.startsWith("/")) {
           const redirectTarget = redirects.get(cleanHref);
           if (redirectTarget) {
@@ -797,7 +1265,7 @@ var crawlabilityRule = {
         rule: "crawlability",
         severity: "warning",
         category: "technical",
-        message: "Missing robots.txt or app/robots.ts file.",
+        message: "Missing robots.txt (or a framework robots declaration file).",
         fixable: true,
         explanation: "Robots.txt directs search crawler access to public sections and points crawlers to your sitemap."
       });
@@ -840,7 +1308,7 @@ var crawlabilityRule = {
         rule: "crawlability",
         severity: "error",
         category: "technical",
-        message: "Missing sitemap.xml or app/sitemap.ts file.",
+        message: "Missing sitemap.xml (or a framework sitemap declaration file).",
         fixable: Boolean(context.config.siteUrl),
         explanation: "An XML sitemap communicates your full URL catalog to Google, ensuring newly published routes are indexed quickly."
       });
@@ -1049,7 +1517,7 @@ var metadataConflictsRule = {
       file: route.filePath,
       route: route.route,
       fixable: false,
-      explanation: "Mixing Metadata exports, generateMetadata, and next/head can produce conflicting search metadata."
+      explanation: "Mixing multiple metadata declaration mechanisms can produce conflicting search metadata."
     }));
   }
 };
@@ -1159,7 +1627,7 @@ function calculateScore(findings) {
 // ../core/src/graph.ts
 function buildLinkGraph(routes, redirects = []) {
   const nodeSet = new Set(routes.map((r) => r.route));
-  const nodes = Array.from(nodeSet);
+  const nodes = Array.from(nodeSet).sort();
   const edges = [];
   const incomingCount = {};
   const outgoingCount = {};
@@ -1169,7 +1637,7 @@ function buildLinkGraph(routes, redirects = []) {
     outgoingCount[node] = 0;
     adjacencyList[node] = [];
   }
-  const normalize = (path5) => path5.endsWith("/") && path5.length > 1 ? path5.slice(0, -1) : path5;
+  const normalize = (path9) => path9.endsWith("/") && path9.length > 1 ? path9.slice(0, -1) : path9;
   const redirectMap = new Map(redirects.map((redirect) => [normalize(redirect.source), normalize(redirect.destination)]));
   for (const route of routes) {
     const source = route.route;
@@ -1238,13 +1706,13 @@ function buildLinkGraph(routes, redirects = []) {
   }
   return {
     nodes,
-    edges,
+    edges: edges.sort((a, b) => `${a.source}\0${a.target}\0${a.anchorText}`.localeCompare(`${b.source}\0${b.target}\0${b.anchorText}`)),
     metrics,
-    orphans,
-    deadEnds,
-    brokenEdges,
-    lowConnectivity,
-    highlyLinked
+    orphans: orphans.sort(),
+    deadEnds: deadEnds.sort(),
+    brokenEdges: brokenEdges.sort((a, b) => `${a.source}\0${a.target}`.localeCompare(`${b.source}\0${b.target}`)),
+    lowConnectivity: lowConnectivity.sort(),
+    highlyLinked: highlyLinked.sort()
   };
 }
 
@@ -1435,8 +1903,8 @@ function detectContentOpportunities(routes, providedKeywords = {}) {
 }
 
 // ../core/src/fixer.ts
-import path2 from "node:path";
-import fs2 from "node:fs";
+import path4 from "node:path";
+import fs4 from "node:fs";
 function createUnifiedDiff(filename, oldText, newText) {
   const oldLines = oldText ? oldText.split("\n") : [];
   const newLines = newText ? newText.split("\n") : [];
@@ -1468,8 +1936,167 @@ function createUnifiedDiff(filename, oldText, newText) {
   }
   return diff;
 }
+function generateRevertSafeFix(options) {
+  const { finding, projectRoot, baseContent, headContent, filePath } = options;
+  if (!baseContent || !headContent) return null;
+  const isCanonical = finding.rule.includes("canonical");
+  const isRobots = finding.rule.includes("robots") || finding.message.includes("noindex");
+  if (isCanonical) {
+    const baseCanonicalMatch = baseContent.match(/canonical\s*:\s*["'`]([^"'`]+)["'`]/) || baseContent.match(/<link\s+rel=["']canonical["']\s+href=["']([^"']+)["']/i);
+    if (baseCanonicalMatch) {
+      const canonicalVal = baseCanonicalMatch[1];
+      if (headContent.includes("export const metadata")) {
+        const updated = headContent.replace(
+          /(export\s+const\s+metadata(?:\s*:\s*Metadata)?\s*=\s*\{)/,
+          `$1
+  alternates: {
+    canonical: '${canonicalVal}',
+  },`
+        );
+        if (updated !== headContent) {
+          return {
+            filePath,
+            originalContent: headContent,
+            newContent: updated,
+            diff: createUnifiedDiff(path4.relative(projectRoot, filePath), headContent, updated),
+            description: `Restored canonical value "${canonicalVal}" from BASE revision.`
+          };
+        }
+      }
+    }
+  }
+  if (isRobots) {
+    if (headContent.includes("noindex")) {
+      const updated = headContent.replace(/["']noindex["']/g, "'index'").replace(/noindex/g, "index");
+      if (updated !== headContent) {
+        return {
+          filePath,
+          originalContent: headContent,
+          newContent: updated,
+          diff: createUnifiedDiff(path4.relative(projectRoot, filePath), headContent, updated),
+          description: "Restored indexable robots directive present in BASE revision."
+        };
+      }
+    }
+  }
+  return null;
+}
+function addCanonicalDeclaration(framework, content, canonicalUrl) {
+  if (content.includes("canonical")) return null;
+  if (framework === "nextjs") {
+    if (content.includes("export const metadata")) {
+      if (content.includes("alternates")) return null;
+      const updatedContent = content.replace(
+        /(export\s+const\s+metadata(?:\s*:\s*Metadata)?\s*=\s*\{)/,
+        `$1
+  alternates: {
+    canonical: '${canonicalUrl}',
+  },`
+      );
+      return updatedContent !== content ? updatedContent : null;
+    }
+    if (content.includes("export default function")) {
+      return `import type { Metadata } from 'next';
+
+export const metadata: Metadata = {
+  alternates: {
+    canonical: '${canonicalUrl}',
+  },
+};
+
+${content}`;
+    }
+    return null;
+  }
+  if (framework === "sveltekit") {
+    const block = `
+  <link rel="canonical" href="${canonicalUrl}" />
+`;
+    const close = "</svelte:head>";
+    const closeIndex = content.indexOf(close);
+    if (closeIndex !== -1) {
+      const updatedContent = content.replace(close, `${block}</svelte:head>`);
+      return updatedContent !== content ? updatedContent : null;
+    }
+    const scriptEnd = content.indexOf("</script>");
+    if (scriptEnd !== -1) {
+      const updatedContent = `${content.slice(0, scriptEnd + "</script>".length)}
+<svelte:head>${block}</svelte:head>${content.slice(scriptEnd + "</script>".length)}`;
+      return updatedContent !== content ? updatedContent : null;
+    }
+    if (/^\s*</.test(content)) {
+      return `<svelte:head>${block}</svelte:head>
+${content}`;
+    }
+    return null;
+  }
+  if (framework === "astro" || framework === "static" || framework === "vite") {
+    const headMatch = content.match(/<head\b[^>]*>/i);
+    if (headMatch && headMatch.index !== void 0) {
+      const insertAt = headMatch.index + headMatch[0].length;
+      const updatedContent = `${content.slice(0, insertAt)}
+    <link rel="canonical" href="${canonicalUrl}" />${content.slice(insertAt)}`;
+      return updatedContent !== content ? updatedContent : null;
+    }
+    return null;
+  }
+  if (framework === "nuxt") {
+    const anchor = "useHead({";
+    const anchorIndex = content.indexOf(anchor);
+    if (anchorIndex === -1) return null;
+    const updatedContent = content.replace(
+      anchor,
+      `useHead({
+    link: [{ rel: 'canonical', href: '${canonicalUrl}' }],`
+    );
+    return updatedContent !== content ? updatedContent : null;
+  }
+  if (framework === "remix") {
+    const direct = content.match(/=>\s*\[/);
+    if (direct && direct.index !== void 0) {
+      const insertAt = direct.index + direct[0].length;
+      const updatedContent = `${content.slice(0, insertAt)}
+    { tagName: 'link', rel: 'canonical', href: '${canonicalUrl}' },${content.slice(insertAt)}`;
+      return updatedContent !== content ? updatedContent : null;
+    }
+    const returnStatement = content.match(/\breturn\s+\[/);
+    if (returnStatement && returnStatement.index !== void 0) {
+      const insertAt = returnStatement.index + returnStatement[0].length;
+      const updatedContent = `${content.slice(0, insertAt)}
+    { tagName: 'link', rel: 'canonical', href: '${canonicalUrl}' },${content.slice(insertAt)}`;
+      return updatedContent !== content ? updatedContent : null;
+    }
+    return null;
+  }
+  return null;
+}
+function assetLayout(projectRoot, framework, isAppRouter) {
+  if (framework === "nextjs" && isAppRouter) {
+    const appDirectory = fs4.existsSync(path4.join(projectRoot, "app")) ? path4.join(projectRoot, "app") : path4.join(projectRoot, "src", "app");
+    return { kind: "app-router", directory: appDirectory };
+  }
+  let directory;
+  switch (framework) {
+    case "sveltekit":
+      directory = path4.join(projectRoot, "static");
+      break;
+    case "static":
+      directory = projectRoot;
+      break;
+    default:
+      directory = path4.join(projectRoot, "public");
+  }
+  return { kind: "file", directory };
+}
+var ROBOTS_TXT = (siteUrl) => `User-agent: *
+Allow: /
+Disallow: /api/
+Disallow: /admin/
+${siteUrl ? `
+Sitemap: ${siteUrl}/sitemap.xml
+` : ""}`;
 async function applySafeFixes(options) {
-  const { projectRoot, routes, findings, config, dryRun = false, isAppRouter = true } = options;
+  const { projectRoot, routes, findings, config, dryRun = false, isAppRouter = true, framework = "nextjs" } = options;
   const appliedChanges = [];
   const skippedFindings = [];
   const scoreBefore = calculateScore(findings);
@@ -1487,31 +2114,54 @@ async function applySafeFixes(options) {
   const validRoutes = routes.filter((r) => !r.hasDynamicSegments).map((r) => r.route);
   const fixedFindingIds = /* @__PURE__ */ new Set();
   const virtualFiles = /* @__PURE__ */ new Map();
-  const appDirectory = fs2.existsSync(path2.join(projectRoot, "app")) ? path2.join(projectRoot, "app") : path2.join(projectRoot, "src", "app");
   const safeFile = (candidate) => {
-    const root = path2.resolve(projectRoot);
-    const resolved = path2.resolve(candidate);
-    return resolved === root || resolved.startsWith(`${root}${path2.sep}`) ? resolved : null;
+    const root = path4.resolve(projectRoot);
+    const resolved = path4.resolve(candidate);
+    return resolved === root || resolved.startsWith(`${root}${path4.sep}`) ? resolved : null;
   };
   const readCurrent = (candidate) => {
     if (virtualFiles.has(candidate)) return virtualFiles.get(candidate);
-    return fs2.existsSync(candidate) ? fs2.readFileSync(candidate, "utf8") : "";
+    return fs4.existsSync(candidate) ? fs4.readFileSync(candidate, "utf8") : "";
   };
   const recordChange = (change, findingId) => {
     appliedChanges.push(change);
     fixedFindingIds.add(findingId);
     virtualFiles.set(change.filePath, change.newContent);
     if (!dryRun) {
-      fs2.mkdirSync(path2.dirname(change.filePath), { recursive: true });
-      fs2.writeFileSync(change.filePath, change.newContent, "utf8");
+      fs4.mkdirSync(path4.dirname(change.filePath), { recursive: true });
+      fs4.writeFileSync(change.filePath, change.newContent, "utf8");
     }
   };
+  const layout = assetLayout(projectRoot, framework, isAppRouter);
+  if (options.baseFiles) {
+    const revertSafeFindings = findings.filter(
+      (f) => f.fixability === "REVERT_SAFE" || f.confidence === "DETERMINISTIC"
+    );
+    for (const f of revertSafeFindings) {
+      const targetFile = f.file ? safeFile(f.file) : null;
+      if (!targetFile) continue;
+      const relPath = path4.relative(projectRoot, targetFile).replace(/\\/g, "/");
+      const baseContent = options.baseFiles.get(relPath) || options.baseFiles.get(targetFile);
+      if (!baseContent) continue;
+      const headContent = readCurrent(targetFile);
+      const fix = generateRevertSafeFix({
+        finding: f,
+        projectRoot,
+        baseContent,
+        headContent,
+        filePath: targetFile
+      });
+      if (fix) {
+        recordChange(fix, f.id);
+      }
+    }
+  }
   const robotsFinding = findings.find((f) => f.rule === "crawlability" && f.id === "robots-missing");
   if (robotsFinding) {
-    if (isAppRouter) {
-      const robotsFilePath = path2.join(appDirectory, "robots.ts");
-      const relativePath = path2.relative(projectRoot, robotsFilePath);
-      const oldContent = fs2.existsSync(robotsFilePath) ? fs2.readFileSync(robotsFilePath, "utf8") : "";
+    if (layout.kind === "app-router") {
+      const robotsFilePath = path4.join(layout.directory, "robots.ts");
+      const relativePath = path4.relative(projectRoot, robotsFilePath);
+      const oldContent = fs4.existsSync(robotsFilePath) ? fs4.readFileSync(robotsFilePath, "utf8") : "";
       const sitemapLine = siteUrl ? `
     sitemap: '${siteUrl}/sitemap.xml',` : "";
       const newContent = `import { MetadataRoute } from 'next';
@@ -1535,22 +2185,16 @@ export default function robots(): MetadataRoute.Robots {
         description: "Generated app/robots.ts with standard crawler rules and sitemap reference."
       }, robotsFinding.id);
     } else {
-      const robotsFilePath = path2.join(projectRoot, "public", "robots.txt");
-      const relativePath = "public/robots.txt";
-      const oldContent = fs2.existsSync(robotsFilePath) ? fs2.readFileSync(robotsFilePath, "utf8") : "";
-      const newContent = `User-agent: *
-Allow: /
-Disallow: /api/
-Disallow: /admin/
-${siteUrl ? `
-Sitemap: ${siteUrl}/sitemap.xml
-` : ""}`;
+      const robotsFilePath = path4.join(layout.directory, "robots.txt");
+      const relativePath = path4.relative(projectRoot, robotsFilePath);
+      const oldContent = fs4.existsSync(robotsFilePath) ? fs4.readFileSync(robotsFilePath, "utf8") : "";
+      const newContent = ROBOTS_TXT(siteUrl);
       recordChange({
         filePath: robotsFilePath,
         originalContent: oldContent,
         newContent,
         diff: createUnifiedDiff(relativePath, oldContent, newContent),
-        description: "Generated public/robots.txt with standard crawler rules and sitemap pointer."
+        description: `Generated ${relativePath} with standard crawler rules and sitemap pointer.`
       }, robotsFinding.id);
     }
   }
@@ -1558,10 +2202,10 @@ Sitemap: ${siteUrl}/sitemap.xml
     (f) => f.rule === "crawlability" && (f.id === "sitemap-missing" || f.id === "sitemap-malformed")
   );
   if (sitemapFinding && siteUrl) {
-    if (isAppRouter) {
-      const sitemapFilePath = path2.join(appDirectory, "sitemap.ts");
-      const relativePath = path2.relative(projectRoot, sitemapFilePath);
-      const oldContent = fs2.existsSync(sitemapFilePath) ? fs2.readFileSync(sitemapFilePath, "utf8") : "";
+    if (layout.kind === "app-router") {
+      const sitemapFilePath = path4.join(layout.directory, "sitemap.ts");
+      const relativePath = path4.relative(projectRoot, sitemapFilePath);
+      const oldContent = fs4.existsSync(sitemapFilePath) ? fs4.readFileSync(sitemapFilePath, "utf8") : "";
       const routeEntries = validRoutes.map(
         (r) => `    {
       url: '${siteUrl}${r === "/" ? "" : r}',
@@ -1586,9 +2230,9 @@ ${routeEntries}
         description: `Generated app/sitemap.ts containing ${validRoutes.length} discovered routes.`
       }, sitemapFinding.id);
     } else {
-      const sitemapFilePath = path2.join(projectRoot, "public", "sitemap.xml");
-      const relativePath = "public/sitemap.xml";
-      const oldContent = fs2.existsSync(sitemapFilePath) ? fs2.readFileSync(sitemapFilePath, "utf8") : "";
+      const sitemapFilePath = path4.join(layout.directory, "sitemap.xml");
+      const relativePath = path4.relative(projectRoot, sitemapFilePath);
+      const oldContent = fs4.existsSync(sitemapFilePath) ? fs4.readFileSync(sitemapFilePath, "utf8") : "";
       const xmlEntries = validRoutes.map(
         (r) => `  <url>
     <loc>${siteUrl}${r === "/" ? "" : r}</loc>
@@ -1606,7 +2250,7 @@ ${xmlEntries}
         originalContent: oldContent,
         newContent,
         diff: createUnifiedDiff(relativePath, oldContent, newContent),
-        description: `Generated public/sitemap.xml containing ${validRoutes.length} discovered routes.`
+        description: `Generated ${relativePath} containing ${validRoutes.length} discovered routes.`
       }, sitemapFinding.id);
     }
   }
@@ -1614,46 +2258,18 @@ ${xmlEntries}
     const canonicalFindings = findings.filter((f) => f.rule === "canonical" && f.fixable && f.file);
     for (const finding of canonicalFindings) {
       const findingFile = finding.file ? safeFile(finding.file) : null;
-      if (!findingFile || !fs2.existsSync(findingFile)) continue;
+      if (!findingFile || !fs4.existsSync(findingFile)) continue;
       const fileContent = readCurrent(findingFile);
       const route = finding.route || "/";
       const canonicalUrl = `${siteUrl}${route === "/" ? "" : route}`;
-      if (fileContent.includes("export const metadata")) {
-        if (!fileContent.includes("alternates")) {
-          const updatedContent = fileContent.replace(
-            /(export\s+const\s+metadata(?:\s*:\s*Metadata)?\s*=\s*\{)/,
-            `$1
-  alternates: {
-    canonical: '${canonicalUrl}',
-  },`
-          );
-          if (updatedContent !== fileContent) {
-            recordChange({
-              filePath: findingFile,
-              originalContent: fileContent,
-              newContent: updatedContent,
-              diff: createUnifiedDiff(path2.relative(projectRoot, findingFile), fileContent, updatedContent),
-              description: `Added canonical alternate "${canonicalUrl}" to metadata in ${path2.basename(findingFile)}.`
-            }, finding.id);
-          }
-        }
-      } else if (fileContent.includes("export default function")) {
-        const metadataBoilerplate = `import type { Metadata } from 'next';
-
-export const metadata: Metadata = {
-  alternates: {
-    canonical: '${canonicalUrl}',
-  },
-};
-
-`;
-        const updatedContent = metadataBoilerplate + fileContent;
+      const updatedContent = addCanonicalDeclaration(framework, fileContent, canonicalUrl);
+      if (updatedContent) {
         recordChange({
           filePath: findingFile,
           originalContent: fileContent,
           newContent: updatedContent,
-          diff: createUnifiedDiff(path2.relative(projectRoot, findingFile), fileContent, updatedContent),
-          description: `Injected canonical metadata export in ${path2.basename(findingFile)}.`
+          diff: createUnifiedDiff(path4.relative(projectRoot, findingFile), fileContent, updatedContent),
+          description: `Added canonical "${canonicalUrl}" declaration to ${path4.basename(findingFile)}.`
         }, finding.id);
       }
     }
@@ -1661,7 +2277,7 @@ export const metadata: Metadata = {
   const fixableLinkFindings = findings.filter((f) => f.rule === "links" && f.fixable && f.file);
   for (const lf of fixableLinkFindings) {
     const linkFile = lf.file ? safeFile(lf.file) : null;
-    if (!linkFile || !fs2.existsSync(linkFile)) continue;
+    if (!linkFile || !fs4.existsSync(linkFile)) continue;
     const fileContent = readCurrent(linkFile);
     const match = lf.message.match(/nonexistent route "([^"]+)"/);
     if (match) {
@@ -1672,15 +2288,15 @@ export const metadata: Metadata = {
       if (normalizedTarget) {
         const escapedHref = brokenHref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const updatedContent = fileContent.replace(
-          new RegExp(`href=["']${escapedHref}["']`, "g"),
-          `href="${normalizedTarget}"`
+          new RegExp(`(href|to)=["']${escapedHref}["']`, "g"),
+          `$1="${normalizedTarget}"`
         );
         if (updatedContent !== fileContent) {
           recordChange({
             filePath: linkFile,
             originalContent: fileContent,
             newContent: updatedContent,
-            diff: createUnifiedDiff(path2.relative(projectRoot, linkFile), fileContent, updatedContent),
+            diff: createUnifiedDiff(path4.relative(projectRoot, linkFile), fileContent, updatedContent),
             description: `Fixed casing of internal link: "${brokenHref}" -> "${normalizedTarget}".`
           }, lf.id);
         }
@@ -1703,6 +2319,74 @@ export const metadata: Metadata = {
   };
 }
 
+// ../core/src/fingerprint.ts
+import crypto from "node:crypto";
+function normalizeFilePath(rawPath) {
+  if (!rawPath) return "";
+  const cleaned = rawPath.replace(/\\/g, "/").trim();
+  const match = cleaned.match(/(?:^|\/)(app\/.*|pages\/.*|src\/.*|public\/.*|[^/]+\.(json|js|ts|mjs|tsx|jsx|html|vue|svelte|astro))$/i);
+  return match ? match[1].toLowerCase() : cleaned.split("/").slice(-2).join("/").toLowerCase();
+}
+function computeFindingFingerprint(finding) {
+  const normalizedFile = normalizeFilePath(finding.sourceFile || finding.file || "");
+  const parts = [
+    finding.rule || "unknown-rule",
+    (finding.route || "").trim().toLowerCase(),
+    normalizedFile
+  ];
+  const semanticTarget = extractSemanticTarget(finding);
+  if (semanticTarget) {
+    parts.push(semanticTarget.toLowerCase());
+  }
+  const raw = parts.join("::");
+  return crypto.createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+function extractSemanticTarget(finding) {
+  const id = finding.id || "";
+  if (id.includes("-duplicate-")) {
+    const parts = id.split("-duplicate-");
+    return `${parts[0]}-duplicate`;
+  }
+  if (id.startsWith("img-")) {
+    const segments = id.split("-");
+    return segments.slice(2).join("-");
+  }
+  if (id.startsWith("link-")) {
+    const segments = id.split("-");
+    return segments.slice(2).join("-");
+  }
+  if (id.startsWith("heading-")) {
+    return id.replace(/^heading-/, "");
+  }
+  if (id.startsWith("canonical-")) {
+    return id.replace(/^canonical-/, "");
+  }
+  if (id.startsWith("robots-")) {
+    return id.replace(/^robots-/, "");
+  }
+  if (id.startsWith("title-")) {
+    return id.replace(/^title-/, "");
+  }
+  if (id.startsWith("desc-")) {
+    return id.replace(/^desc-/, "");
+  }
+  const cleanedMessage = (finding.message || "").replace(/\s*\(?(?:\/[a-zA-Z0-9_\-/*]+(?:,\s*)?)+\)?/g, "");
+  return cleanedMessage.trim();
+}
+function enrichFinding(finding) {
+  const fingerprint = finding.fingerprint || computeFindingFingerprint(finding);
+  const confidence = finding.confidence || (finding.rule.includes("heuristic") ? "HEURISTIC" : "DETERMINISTIC");
+  const fixability = finding.fixability || (finding.fixable ? "AUTO_FIXABLE" : "NOT_FIXABLE");
+  return {
+    ...finding,
+    fingerprint,
+    confidence,
+    fixability,
+    sourceFile: finding.sourceFile || finding.file,
+    sourceLine: finding.sourceLine || finding.line
+  };
+}
+
 // ../core/src/engine.ts
 function runSEOAudit(options) {
   const {
@@ -1715,7 +2399,8 @@ function runSEOAudit(options) {
     sitemapMalformed = false,
     redirects = [],
     projectRoot = "",
-    isAppRouter = true
+    isAppRouter = true,
+    timestamp = (/* @__PURE__ */ new Date()).toISOString()
   } = options;
   const ignored = config.ignore || ["/admin/**", "/api/**"];
   const matchesIgnore = (route, pattern) => {
@@ -1740,14 +2425,15 @@ function runSEOAudit(options) {
     "metadata-description": "requireDescription"
   };
   const ruleSetting = (ruleId) => config.rules?.[ruleId] ?? (ruleAliases[ruleId] ? config.rules?.[ruleAliases[ruleId]] : void 0);
-  const findings = allRules.filter((rule) => ruleSetting(rule.id) !== false).flatMap((rule) => {
+  const rawFindings = allRules.filter((rule) => ruleSetting(rule.id) !== false).flatMap((rule) => {
     const results = rule.analyze(ruleContext);
     const configured = ruleSetting(rule.id);
     if (configured && typeof configured === "object" && configured.severity) {
       return results.map((finding) => ({ ...finding, severity: configured.severity }));
     }
     return results;
-  }).sort((a, b) => a.id.localeCompare(b.id));
+  });
+  const findings = rawFindings.map(enrichFinding).sort((a, b) => a.id.localeCompare(b.id));
   const score = calculateScore(findings);
   const linkGraph = buildLinkGraph(analyzedRoutes, redirects);
   const recommendations = generateLinkRecommendations(analyzedRoutes);
@@ -1759,43 +2445,1711 @@ function runSEOAudit(options) {
     linkGraph,
     recommendations,
     opportunities,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    engineVersion: "0.1.0"
+    timestamp,
+    engineVersion: "0.2.0"
   };
 }
 
-// src/formatter.ts
-import path3 from "node:path";
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m",
-  bgRed: "\x1B[41m",
-  bgGreen: "\x1B[42m"
+// ../core/src/quality-gate.ts
+var DEFAULT_QUALITY_GATE_POLICY = {
+  maxNewCritical: 0,
+  maxNewErrors: 0,
+  maxNewWarnings: 10,
+  blockOnNewOrphanRoutes: true
 };
-function formatScoreBadge(score) {
-  if (score >= 85) return `${colors.green}${colors.bold}${score}/100${colors.reset}`;
-  if (score >= 70) return `${colors.yellow}${colors.bold}${score}/100${colors.reset}`;
-  return `${colors.red}${colors.bold}${score}/100${colors.reset}`;
-}
-function printAuditReport(result, projectRoot) {
-  const { score, findings, routes } = result;
-  console.log("\n" + colors.cyan + colors.bold + "\u{1F50D} Crawlemon Audit" + colors.reset + ` (${routes.length} routes scanned)`);
-  console.log(colors.dim + "\u2500".repeat(50) + colors.reset);
-  console.log(`
-  SEO Score: ${formatScoreBadge(score.overall)}`);
-  console.log(`  ${colors.dim}Technical:     ${score.breakdown.technical.toString().padEnd(4)} Metadata:       ${score.breakdown.metadata}`);
-  console.log(`  Content:       ${score.breakdown.content.toString().padEnd(4)} Internal Links: ${score.breakdown.links}${colors.reset}
-`);
-  if (findings.length === 0) {
-    console.log(`${colors.green}\u2713 All checks passed! No SEO regressions or issues found.${colors.reset}
-`);
-    return;
+function evaluateQualityGate(input) {
+  const {
+    newFindings,
+    fixedFindings,
+    baselineDebt,
+    newOrphanRoutes = [],
+    affectedRoutes = [],
+    policy = DEFAULT_QUALITY_GATE_POLICY,
+    baselineTotalIssues,
+    routesResolvedCount = 0
+  } = input;
+  const policyViolations = [];
+  const blockingFindings = newFindings.filter((f) => {
+    const confidence = f.confidence ?? "DETERMINISTIC";
+    return confidence === "DETERMINISTIC" || confidence === "AI_VERIFIED" || confidence === "STRUCTURAL";
+  });
+  const newCritical = blockingFindings.filter(
+    (f) => f.severity === "error" && (f.confidence === "DETERMINISTIC" || f.confidence === "STRUCTURAL")
+  ).length;
+  const newErrors = blockingFindings.filter((f) => f.severity === "error").length;
+  const newWarnings = blockingFindings.filter((f) => f.severity === "warning").length;
+  const maxNewCritical = policy.maxNewCritical ?? 0;
+  const maxNewErrors = policy.maxNewErrors ?? 0;
+  const maxNewWarnings = policy.maxNewWarnings ?? 10;
+  if (newCritical > maxNewCritical) {
+    policyViolations.push(`New critical SEO regressions detected (${newCritical} > ${maxNewCritical}).`);
+  }
+  if (newErrors > maxNewErrors) {
+    policyViolations.push(`New deterministic SEO errors introduced (${newErrors} > ${maxNewErrors}).`);
+  }
+  if (policy.blockOnNewOrphanRoutes && newOrphanRoutes.length > 0) {
+    policyViolations.push(`Internal link regression: ${newOrphanRoutes.length} route(s) became newly orphaned (${newOrphanRoutes.join(", ")}).`);
+  }
+  if (newWarnings > maxNewWarnings) {
+    policyViolations.push(`New warnings exceed threshold (${newWarnings} > ${maxNewWarnings}).`);
+  }
+  let status = "PASS";
+  if (policyViolations.length > 0) {
+    status = "FAIL";
+  } else if (newWarnings > 0 || newOrphanRoutes.length > 0 && !policy.blockOnNewOrphanRoutes) {
+    status = "WARN";
+  }
+  const passed = status !== "FAIL";
+  const routesAtRisk = !passed ? affectedRoutes.length : 0;
+  const routesProtected = passed ? routesResolvedCount : 0;
+  return {
+    status,
+    passed,
+    summary: {
+      newCritical,
+      newErrors,
+      newWarnings,
+      fixedFindings: fixedFindings.length,
+      unchangedFindings: baselineDebt.length,
+      affectedRoutesCount: affectedRoutes.length,
+      baselineTotalIssues: baselineTotalIssues ?? baselineDebt.length,
+      routesAtRisk,
+      routesProtected
+    },
+    newRegressions: newFindings,
+    fixedFindings,
+    baselineDebt,
+    policyViolations
+  };
+}
+
+// ../core/src/diff-engine.ts
+import path5 from "node:path";
+
+// ../core/src/contracts.ts
+function matchesRoutePattern(route, pattern) {
+  if (pattern === "/**" || pattern === "*") return true;
+  if (pattern === route) return true;
+  const normRoute = route.startsWith("/") ? route : `/${route}`;
+  const normPattern = pattern.startsWith("/") ? pattern : `/${pattern}`;
+  const tokenized = normPattern.replace(/\/\*\*/g, "/___GLOBSTAR___").replace(/\*\*/g, "___GLOBSTAR___").replace(/\*/g, "___SINGLESTAR___");
+  const escaped = tokenized.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const regexStr = "^" + escaped.replace(/\/___GLOBSTAR___/g, "(?:/.*)?").replace(/___GLOBSTAR___/g, ".*").replace(/___SINGLESTAR___/g, "[^/]*") + "$";
+  try {
+    const regex = new RegExp(regexStr);
+    return regex.test(normRoute);
+  } catch {
+    return normRoute.startsWith(pattern.replace(/\*+/g, ""));
+  }
+}
+function evaluateSEOContracts(options) {
+  const { routes, contracts, linkGraph } = options;
+  const findings = [];
+  for (const contract of contracts) {
+    const matchingRoutes = routes.filter((r) => {
+      if (contract.exclude && contract.exclude.some((ex) => matchesRoutePattern(r.route, ex))) {
+        return false;
+      }
+      return contract.routes.some((pattern) => matchesRoutePattern(r.route, pattern));
+    });
+    const req = contract.requirement;
+    for (const r of matchingRoutes) {
+      if (req.indexable === true) {
+        const robots = (r.metadata?.robots || "").toLowerCase();
+        if (robots.includes("noindex")) {
+          findings.push({
+            id: `contract-${contract.name}-indexable-${r.route}`,
+            rule: `contract/${contract.name}`,
+            severity: "error",
+            category: "technical",
+            confidence: "DETERMINISTIC",
+            fixability: "REVERT_SAFE",
+            status: "NEW",
+            message: `SEO Contract violation in "${contract.name}": Route "${r.route}" must remain indexable, but robots contains "noindex".`,
+            file: r.filePath,
+            route: r.route,
+            fixable: true,
+            explanation: `Contract "${contract.name}" mandates that all matching routes remain indexable to search engines.`,
+            evidenceChain: {
+              sourceFile: r.filePath,
+              changeDescription: `robots changed to "${r.metadata?.robots}"`,
+              whyThisHappened: `Route "${r.route}" violated contract "${contract.name}" requirement: indexable=true.`,
+              steps: [
+                {
+                  type: "CONTRACT_VIOLATION",
+                  from: r.filePath,
+                  to: r.route,
+                  detail: `robots: "${r.metadata?.robots}" violates indexable requirement`
+                }
+              ],
+              affectedRoutesCount: 1,
+              sampleRoutes: [r.route],
+              confidence: "DETERMINISTIC",
+              revertSafeValue: "index, follow",
+              fixRecommendation: `Restore robots declaration to allow indexing.`
+            }
+          });
+        }
+      }
+      if (req.canonical === "required" && !r.metadata?.canonical) {
+        findings.push({
+          id: `contract-${contract.name}-canonical-${r.route}`,
+          rule: `contract/${contract.name}`,
+          severity: "error",
+          category: "metadata",
+          confidence: "DETERMINISTIC",
+          fixability: "DETERMINISTIC_FIX",
+          status: "NEW",
+          message: `SEO Contract violation in "${contract.name}": Canonical URL is required on "${r.route}".`,
+          file: r.filePath,
+          route: r.route,
+          fixable: true,
+          explanation: `Contract "${contract.name}" requires an explicit canonical tag on all matching routes.`,
+          evidenceChain: {
+            sourceFile: r.filePath,
+            changeDescription: "canonical declaration missing",
+            whyThisHappened: `Route "${r.route}" violated contract "${contract.name}" requirement: canonical=required.`,
+            steps: [
+              {
+                type: "CONTRACT_VIOLATION",
+                from: r.filePath,
+                to: r.route,
+                detail: `canonical missing`
+              }
+            ],
+            affectedRoutesCount: 1,
+            sampleRoutes: [r.route],
+            confidence: "DETERMINISTIC",
+            fixRecommendation: `Declare explicit canonical link on "${r.route}".`
+          }
+        });
+      }
+      if (req.internalLinks?.minimumInbound !== void 0 && linkGraph) {
+        const metrics = linkGraph.metrics?.[r.route];
+        const inbound = metrics?.incomingLinks ?? 0;
+        if (inbound < req.internalLinks.minimumInbound) {
+          findings.push({
+            id: `contract-${contract.name}-min-inbound-${r.route}`,
+            rule: `contract/${contract.name}`,
+            severity: "error",
+            category: "links",
+            confidence: "STRUCTURAL",
+            fixability: "SUGGESTED_FIX",
+            status: "NEW",
+            message: `SEO Contract violation in "${contract.name}": Route "${r.route}" has ${inbound} incoming link(s), but contract requires at least ${req.internalLinks.minimumInbound}.`,
+            file: r.filePath,
+            route: r.route,
+            fixable: false,
+            explanation: `Contract "${contract.name}" requires minimum ${req.internalLinks.minimumInbound} inbound internal links to prevent orphan routes.`,
+            evidenceChain: {
+              sourceFile: r.filePath,
+              changeDescription: `incoming links = ${inbound} (required: >= ${req.internalLinks.minimumInbound})`,
+              whyThisHappened: `Route became under-linked or orphaned after code changes.`,
+              steps: [
+                {
+                  type: "LINK_EDGE_REMOVAL",
+                  from: "Internal Link Graph",
+                  to: r.route,
+                  detail: `Current inbound: ${inbound}, required: ${req.internalLinks.minimumInbound}`
+                }
+              ],
+              affectedRoutesCount: 1,
+              sampleRoutes: [r.route],
+              confidence: "STRUCTURAL",
+              fixRecommendation: `Add internal links pointing to "${r.route}" from navigation or parent routes.`
+            }
+          });
+        }
+      }
+      if (req.schema?.required) {
+        const expectedType = req.schema.type;
+        const jsonLd = r.metadata?.jsonLd || [];
+        const hasMatchingSchema = jsonLd.some((item) => {
+          if (!expectedType) return true;
+          const type = item["@type"] || item.type;
+          return type?.toLowerCase() === expectedType.toLowerCase();
+        });
+        if (!hasMatchingSchema) {
+          findings.push({
+            id: `contract-${contract.name}-schema-${r.route}`,
+            rule: `contract/${contract.name}`,
+            severity: "error",
+            category: "technical",
+            confidence: "DETERMINISTIC",
+            fixability: "SUGGESTED_FIX",
+            status: "NEW",
+            message: `SEO Contract violation in "${contract.name}": Missing required JSON-LD schema${expectedType ? ` "${expectedType}"` : ""} on "${r.route}".`,
+            file: r.filePath,
+            route: r.route,
+            fixable: false,
+            explanation: `Contract "${contract.name}" mandates structured data (${expectedType || "Schema.org"}) on this route pattern.`,
+            evidenceChain: {
+              sourceFile: r.filePath,
+              changeDescription: `Schema ${expectedType || "JSON-LD"} missing`,
+              whyThisHappened: `Route "${r.route}" failed contract requirement: schema.required=true.`,
+              steps: [
+                {
+                  type: "CONTRACT_VIOLATION",
+                  from: r.filePath,
+                  to: r.route,
+                  detail: `missing @type: ${expectedType || "any"}`
+                }
+              ],
+              affectedRoutesCount: 1,
+              sampleRoutes: [r.route],
+              confidence: "DETERMINISTIC",
+              fixRecommendation: `Add JSON-LD script containing @type: "${expectedType || "WebPage"}".`
+            }
+          });
+        }
+      }
+    }
+  }
+  return findings;
+}
+function suggestSEOContracts(routes) {
+  const contracts = [];
+  const sections = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    const parts = r.route.split("/").filter(Boolean);
+    if (parts.length >= 1) {
+      const section = parts[0];
+      if (!sections.has(section)) sections.set(section, []);
+      sections.get(section).push(r);
+    }
+  }
+  for (const [section, sectionRoutes] of sections) {
+    if (sectionRoutes.length >= 2) {
+      const allIndexable = sectionRoutes.every((r) => !(r.metadata?.robots || "").includes("noindex"));
+      const allCanonical = sectionRoutes.every((r) => Boolean(r.metadata?.canonical));
+      if (allIndexable || allCanonical) {
+        contracts.push({
+          name: `${section}-pages`,
+          routes: [`/${section}/**`],
+          requirement: {
+            indexable: allIndexable ? true : void 0,
+            canonical: allCanonical ? "required" : "optional"
+          }
+        });
+      }
+    }
+  }
+  return contracts;
+}
+
+// ../core/src/seo-graph.ts
+function normalizeRoute(pathStr) {
+  if (pathStr.length > 1 && pathStr.endsWith("/")) {
+    return pathStr.slice(0, -1);
+  }
+  return pathStr;
+}
+function buildSEODependencyGraph(routes, options = {}) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  const edges = [];
+  const addNode = (node) => {
+    if (!nodeMap.has(node.id)) {
+      nodeMap.set(node.id, node);
+    }
+  };
+  const addEdge = (edge) => {
+    edges.push(edge);
+  };
+  const layouts = options.layouts || [];
+  for (const layout of layouts) {
+    const layoutId = `layout:${layout.filePath}`;
+    addNode({
+      id: layoutId,
+      type: "layout",
+      label: layout.filePath,
+      path: layout.filePath,
+      metadata: layout.metadata
+    });
+    if (layout.parentDir !== void 0) {
+      const parentLayout = layouts.find((l) => l.relativeDir === layout.parentDir);
+      if (parentLayout) {
+        addEdge({
+          source: layoutId,
+          target: `layout:${parentLayout.filePath}`,
+          type: "INHERITS_FROM",
+          detail: "layout inheritance"
+        });
+      }
+    }
+  }
+  for (const route of routes) {
+    const routeId = `route:${normalizeRoute(route.route)}`;
+    addNode({
+      id: routeId,
+      type: "route",
+      label: route.route,
+      path: route.filePath,
+      metadata: {
+        canonical: route.metadata?.canonical,
+        robots: route.metadata?.robots,
+        title: route.metadata?.title,
+        description: route.metadata?.description
+      }
+    });
+    if (route.filePath) {
+      const fileId = `file:${route.filePath}`;
+      addNode({
+        id: fileId,
+        type: "source_file",
+        label: route.filePath,
+        path: route.filePath
+      });
+      addEdge({
+        source: fileId,
+        target: routeId,
+        type: "DEFINES_METADATA",
+        detail: "page component defines route"
+      });
+    }
+    if (layouts.length > 0) {
+      const matchingLayouts = layouts.filter((l) => {
+        const layoutDir = l.relativeDir.replace(/\\/g, "/");
+        if (layoutDir === "" || layoutDir === ".") return true;
+        const normalizedFilePath = route.filePath.replace(/\\/g, "/");
+        return normalizedFilePath.includes(`/${layoutDir}/`) || normalizedFilePath.includes(`${layoutDir}/`);
+      });
+      for (const layout of matchingLayouts) {
+        addEdge({
+          source: routeId,
+          target: `layout:${layout.filePath}`,
+          type: "INHERITS_FROM",
+          detail: "metadata inheritance"
+        });
+      }
+    }
+    if (route.metadata?.canonical) {
+      const cleanCanonical = normalizeRoute(route.metadata.canonical);
+      if (cleanCanonical.startsWith("/")) {
+        const canonicalTargetId = `route:${cleanCanonical}`;
+        addEdge({
+          source: routeId,
+          target: canonicalTargetId,
+          type: "CANONICALIZES_TO",
+          detail: route.metadata.canonical
+        });
+      }
+    }
+  }
+  if (options.linkGraph?.edges) {
+    for (const linkEdge of options.linkGraph.edges) {
+      const sourceId = `route:${normalizeRoute(linkEdge.source)}`;
+      const targetId = `route:${normalizeRoute(linkEdge.target)}`;
+      addEdge({
+        source: sourceId,
+        target: targetId,
+        type: "LINKS_TO",
+        detail: linkEdge.anchorText
+      });
+    }
+  }
+  if (options.redirects) {
+    for (const r of options.redirects) {
+      const sourceId = `route:${normalizeRoute(r.source)}`;
+      const targetId = `route:${normalizeRoute(r.destination)}`;
+      addEdge({
+        source: sourceId,
+        target: targetId,
+        type: "REDIRECTS_TO",
+        detail: r.permanent ? "301 Permanent" : "302 Temporary"
+      });
+    }
+  }
+  if (options.inferredSemanticEdges) {
+    for (const semEdge of options.inferredSemanticEdges) {
+      addEdge(semEdge);
+    }
+  }
+  return {
+    nodes: Array.from(nodeMap.values()).sort((a, b) => a.id.localeCompare(b.id)),
+    edges: edges.sort((a, b) => `${a.source}\0${a.type}\0${a.target}`.localeCompare(`${b.source}\0${b.type}\0${b.target}`))
+  };
+}
+function computeGraphDiff(baseGraph, headGraph) {
+  const baseNodeMap = new Map(baseGraph.nodes.map((n) => [n.id, n]));
+  const headNodeMap = new Map(headGraph.nodes.map((n) => [n.id, n]));
+  const addedNodes = [];
+  const removedNodes = [];
+  const mutatedMetadata = [];
+  for (const [id, headNode] of headNodeMap) {
+    if (!baseNodeMap.has(id)) {
+      addedNodes.push(headNode);
+    } else {
+      const baseNode = baseNodeMap.get(id);
+      if (baseNode.metadata || headNode.metadata) {
+        const allKeys = /* @__PURE__ */ new Set([
+          ...Object.keys(baseNode.metadata || {}),
+          ...Object.keys(headNode.metadata || {})
+        ]);
+        for (const key of allKeys) {
+          const oldVal = baseNode.metadata?.[key];
+          const newVal = headNode.metadata?.[key];
+          if (oldVal !== newVal) {
+            mutatedMetadata.push({
+              nodeId: id,
+              property: key,
+              oldValue: oldVal,
+              newValue: newVal
+            });
+          }
+        }
+      }
+    }
+  }
+  for (const [id, baseNode] of baseNodeMap) {
+    if (!headNodeMap.has(id)) {
+      removedNodes.push(baseNode);
+    }
+  }
+  const edgeKey2 = (e) => `${e.source} -[${e.type}]-> ${e.target}`;
+  const baseEdgeMap = new Map(baseGraph.edges.map((e) => [edgeKey2(e), e]));
+  const headEdgeMap = new Map(headGraph.edges.map((e) => [edgeKey2(e), e]));
+  const addedEdges = [];
+  const removedEdges = [];
+  for (const [key, edge] of headEdgeMap) {
+    if (!baseEdgeMap.has(key)) addedEdges.push(edge);
+  }
+  for (const [key, edge] of baseEdgeMap) {
+    if (!headEdgeMap.has(key)) removedEdges.push(edge);
+  }
+  return {
+    addedNodes: addedNodes.sort((a, b) => a.id.localeCompare(b.id)),
+    removedNodes: removedNodes.sort((a, b) => a.id.localeCompare(b.id)),
+    addedEdges: addedEdges.sort((a, b) => edgeKey2(a).localeCompare(edgeKey2(b))),
+    removedEdges: removedEdges.sort((a, b) => edgeKey2(a).localeCompare(edgeKey2(b))),
+    mutatedMetadata: mutatedMetadata.sort((a, b) => `${a.nodeId}\0${a.property}`.localeCompare(`${b.nodeId}\0${b.property}`))
+  };
+}
+function traceDownstreamRoutes(graph, sourceFileOrLayout) {
+  const affectedRoutes = /* @__PURE__ */ new Set();
+  const matchingNodeIds = graph.nodes.filter((n) => n.path === sourceFileOrLayout || n.id.includes(sourceFileOrLayout)).map((n) => n.id);
+  if (matchingNodeIds.length === 0) return [];
+  for (const edge of graph.edges) {
+    if ((edge.type === "INHERITS_FROM" || edge.type === "DEFINES_METADATA") && matchingNodeIds.includes(edge.target)) {
+      if (edge.source.startsWith("route:")) {
+        affectedRoutes.add(edge.source.replace(/^route:/, ""));
+      }
+    }
+    if (edge.type === "DEFINES_METADATA" && matchingNodeIds.includes(edge.source)) {
+      if (edge.target.startsWith("route:")) {
+        affectedRoutes.add(edge.target.replace(/^route:/, ""));
+      }
+    }
+  }
+  return Array.from(affectedRoutes).sort();
+}
+
+// ../core/src/diff-engine.ts
+function edgeKey(edge) {
+  return `${edge.source} -> ${edge.target} [${edge.anchorText}]`;
+}
+function enrichEvidenceChain(finding, isRegression) {
+  if (finding.evidenceChain) return finding;
+  const isCanonical = finding.rule.includes("canonical");
+  const isRobots = finding.rule.includes("robots") || finding.message.includes("noindex");
+  const isCriticalTechnical = isCanonical || isRobots;
+  const isLayoutSource = Boolean(
+    finding.sourceFile?.includes("layout") || finding.file?.includes("layout") || finding.affectedRoutes && finding.affectedRoutes.length > 1
+  );
+  let confidence = finding.confidence || "DETERMINISTIC";
+  let fixability = finding.fixability || "SUGGESTED_FIX";
+  if (isCriticalTechnical && isRegression) {
+    confidence = isLayoutSource ? "STRUCTURAL" : "DETERMINISTIC";
+    fixability = "REVERT_SAFE";
+  } else if (finding.rule.includes("contract")) {
+    confidence = "DETERMINISTIC";
+  } else if (finding.severity === "info" || finding.category === "content") {
+    confidence = "HEURISTIC";
+  }
+  const steps = [];
+  const source = finding.sourceFile || finding.file || "unknown source";
+  const targetRoute = finding.route || finding.routePattern || "/";
+  if (isLayoutSource) {
+    steps.push({
+      type: "LAYOUT_INHERITANCE",
+      from: source,
+      to: targetRoute,
+      detail: "Metadata inherited by nested routes"
+    });
+  } else {
+    steps.push({
+      type: "DIRECT_MUTATION",
+      from: source,
+      to: targetRoute,
+      detail: finding.message
+    });
+  }
+  const affectedCount = Math.max(1, finding.affectedRoutes?.length || 1);
+  const sampleRoutes = finding.affectedRoutes && finding.affectedRoutes.length > 0 ? finding.affectedRoutes.slice(0, 3) : [targetRoute];
+  const evidenceChain = {
+    sourceFile: source,
+    sourceLine: finding.sourceLine || finding.line,
+    changeDescription: isRegression ? `Regression introduced: ${finding.message}` : finding.message,
+    whyThisHappened: isLayoutSource ? `${source} defines metadata inherited by all nested routes.` : `File ${source} directly configures SEO attributes for ${targetRoute}.`,
+    steps,
+    affectedRoutesCount: affectedCount,
+    sampleRoutes,
+    confidence,
+    revertSafeValue: fixability === "REVERT_SAFE" ? "Restore previous declaration from BASE" : void 0,
+    fixRecommendation: fixability === "REVERT_SAFE" ? "Restore previous declaration from BASE." : "Update file declaration according to best practices."
+  };
+  return {
+    ...finding,
+    confidence,
+    fixability,
+    evidenceChain
+  };
+}
+function consolidateRegressionsByRootCause(rawNewFindings, baseAudit, headAudit, headSEOGraph, seoGraphDiff) {
+  const consolidated = [];
+  const handledIds = /* @__PURE__ */ new Set();
+  const layoutMutations = seoGraphDiff.mutatedMetadata.filter((m) => m.nodeId.startsWith("layout:"));
+  for (const mut of layoutMutations) {
+    const layoutPath = mut.nodeId.replace(/^layout:/, "");
+    const downstream = traceDownstreamRoutes(headSEOGraph, layoutPath);
+    if (downstream.length === 0) continue;
+    const prop = mut.property;
+    const matching = rawNewFindings.filter((f) => {
+      if (handledIds.has(f.id)) return false;
+      const routeMatch = f.route && downstream.includes(f.route);
+      const propMatch = prop === "canonical" ? f.rule.includes("canonical") : f.rule.includes("robots") || f.message.includes("noindex");
+      return routeMatch && propMatch;
+    });
+    if (matching.length > 0) {
+      for (const m of matching) handledIds.add(m.id);
+      const isCanonical = prop === "canonical";
+      const baseName = path5.basename(layoutPath);
+      consolidated.push({
+        id: `regression-${baseName}-${prop}`,
+        rule: isCanonical ? "metadata/canonical-regression" : "crawlability/robots-regression",
+        severity: "error",
+        category: isCanonical ? "metadata" : "technical",
+        confidence: "STRUCTURAL",
+        fixability: "REVERT_SAFE",
+        status: "NEW",
+        message: isCanonical ? `Canonical declaration removed from ${baseName}` : `Robots directive changed in ${baseName}`,
+        file: layoutPath,
+        sourceFile: layoutPath,
+        rootCause: {
+          file: layoutPath,
+          changeDescription: isCanonical ? "alternates.canonical removed from layout" : `robots directive changed in layout`
+        },
+        affectedRoutes: downstream,
+        fixable: true,
+        explanation: `${layoutPath} defines inherited metadata for ${downstream.length} nested route(s). Modifying it propagated this regression to all child routes.`,
+        evidenceChain: {
+          sourceFile: layoutPath,
+          changeDescription: isCanonical ? "alternates.canonical removed from layout" : `robots directive changed in layout`,
+          whyThisHappened: `${layoutPath} defines metadata inherited by all nested routes.`,
+          steps: [
+            {
+              type: "LAYOUT_INHERITANCE",
+              from: layoutPath,
+              to: downstream.length === 1 ? downstream[0] : `${downstream.length} nested routes`,
+              detail: "metadata inheritance"
+            }
+          ],
+          affectedRoutesCount: downstream.length,
+          sampleRoutes: downstream.slice(0, 3),
+          confidence: "STRUCTURAL",
+          revertSafeValue: mut.oldValue ? String(mut.oldValue) : void 0,
+          fixRecommendation: `Restore previous ${prop} declaration from BASE revision in ${baseName}.`
+        }
+      });
+    }
+  }
+  const baseRouteMap = new Map((baseAudit.routes || []).map((r) => [r.route, r]));
+  const unhandled = rawNewFindings.filter((f) => !handledIds.has(f.id));
+  const canonicalRegressions = unhandled.filter((f) => f.rule.includes("canonical"));
+  const robotsRegressions = unhandled.filter((f) => f.rule.includes("robots") || f.message.includes("noindex"));
+  const tryGroupCategory = (groupFindings, signal) => {
+    if (groupFindings.length === 0) return;
+    const byDir = /* @__PURE__ */ new Map();
+    for (const f of groupFindings) {
+      if (!f.route) continue;
+      const parts = f.route.split("/").filter(Boolean);
+      const dir = parts.length > 1 ? `/${parts[0]}` : "/";
+      if (!byDir.has(dir)) byDir.set(dir, []);
+      byDir.get(dir).push(f);
+    }
+    for (const [dir, dirFindings] of byDir) {
+      const hadInBase = dirFindings.every((f) => {
+        const baseR = baseRouteMap.get(f.route);
+        if (signal === "canonical") return Boolean(baseR?.metadata?.canonical);
+        return !(baseR?.metadata?.robots || "").includes("noindex");
+      });
+      if (hadInBase && dirFindings.length > 1) {
+        const layoutNode = headSEOGraph.nodes.find(
+          (n) => n.type === "layout" && (n.path?.includes(dir.replace("/", "")) || n.id.includes(dir.replace("/", "")))
+        );
+        const inferredLayoutFile = layoutNode?.path || `app${dir}/layout.tsx`;
+        const baseName = path5.basename(inferredLayoutFile);
+        const affected = dirFindings.map((f) => f.route).sort();
+        for (const df of dirFindings) handledIds.add(df.id);
+        consolidated.push({
+          id: `regression-${baseName}-${signal}`,
+          rule: signal === "canonical" ? "metadata/canonical-regression" : "crawlability/robots-regression",
+          severity: "error",
+          category: signal === "canonical" ? "metadata" : "technical",
+          confidence: "STRUCTURAL",
+          fixability: "REVERT_SAFE",
+          status: "NEW",
+          message: signal === "canonical" ? `Canonical declaration removed from ${baseName}` : `Robots directive changed in ${baseName}`,
+          file: inferredLayoutFile,
+          sourceFile: inferredLayoutFile,
+          rootCause: {
+            file: inferredLayoutFile,
+            changeDescription: signal === "canonical" ? "alternates.canonical removed from layout" : `robots directive changed in layout`
+          },
+          affectedRoutes: affected,
+          fixable: true,
+          explanation: `${inferredLayoutFile} defines inherited metadata for ${affected.length} nested route(s). Modifying it propagated this regression to all child routes.`,
+          evidenceChain: {
+            sourceFile: inferredLayoutFile,
+            changeDescription: signal === "canonical" ? "alternates.canonical removed from layout" : `robots directive changed in layout`,
+            whyThisHappened: `${inferredLayoutFile} defines metadata inherited by all nested routes.`,
+            steps: [
+              {
+                type: "LAYOUT_INHERITANCE",
+                from: inferredLayoutFile,
+                to: `${affected.length} nested routes`,
+                detail: "metadata inheritance"
+              }
+            ],
+            affectedRoutesCount: affected.length,
+            sampleRoutes: affected.slice(0, 3),
+            confidence: "STRUCTURAL",
+            revertSafeValue: "Restore previous declaration from BASE revision",
+            fixRecommendation: `Restore previous ${signal} declaration from BASE revision in ${baseName}.`
+          }
+        });
+      }
+    }
+  };
+  tryGroupCategory(canonicalRegressions, "canonical");
+  tryGroupCategory(robotsRegressions, "robots");
+  for (const f of rawNewFindings) {
+    if (!handledIds.has(f.id)) {
+      consolidated.push(f);
+    }
+  }
+  return consolidated;
+}
+function computeAuditDiff(baseAudit, headAudit, policyOrOptions) {
+  const options = policyOrOptions && ("contracts" in policyOrOptions || "maxNewCritical" in policyOrOptions) ? { policy: policyOrOptions } : policyOrOptions || {};
+  const policy = options.policy;
+  const baseFindings = (baseAudit.findings || []).map(enrichFinding);
+  let headFindings = (headAudit.findings || []).map(enrichFinding);
+  const baselineTotalIssues = baseAudit.findings?.length ?? 0;
+  if (policy?.contracts && headAudit.routes) {
+    const contractsList = Object.entries(policy.contracts).map(([name, c]) => ({
+      name,
+      routes: c.routes,
+      exclude: c.exclude,
+      requirement: c
+    }));
+    const contractFindings = evaluateSEOContracts({
+      routes: headAudit.routes,
+      contracts: contractsList,
+      linkGraph: headAudit.linkGraph
+    }).map(enrichFinding);
+    headFindings = [...headFindings, ...contractFindings];
+  }
+  const baseMap = /* @__PURE__ */ new Map();
+  for (const f of baseFindings) {
+    baseMap.set(f.fingerprint, f);
+  }
+  const headMap = /* @__PURE__ */ new Map();
+  for (const f of headFindings) {
+    headMap.set(f.fingerprint, f);
+  }
+  const rawNewFindings = [];
+  const unchangedFindings = [];
+  for (const f of headFindings) {
+    if (baseMap.has(f.fingerprint)) {
+      unchangedFindings.push({ ...f, status: "UNCHANGED" });
+    } else {
+      const enriched = enrichEvidenceChain({ ...f, status: "NEW" }, true);
+      rawNewFindings.push(enriched);
+    }
+  }
+  const fixedFindings = [];
+  for (const f of baseFindings) {
+    if (!headMap.has(f.fingerprint)) {
+      fixedFindings.push({ ...f, status: "FIXED" });
+    }
+  }
+  const baseEdges = /* @__PURE__ */ new Map();
+  for (const edge of baseAudit.linkGraph?.edges || []) {
+    baseEdges.set(edgeKey(edge), edge);
+  }
+  const headEdges = /* @__PURE__ */ new Map();
+  for (const edge of headAudit.linkGraph?.edges || []) {
+    headEdges.set(edgeKey(edge), edge);
+  }
+  const newEdges = [];
+  for (const [key, edge] of headEdges) {
+    if (!baseEdges.has(key)) newEdges.push(edge);
+  }
+  const removedEdges = [];
+  for (const [key, edge] of baseEdges) {
+    if (!headEdges.has(key)) removedEdges.push(edge);
+  }
+  const baseOrphans = new Set(baseAudit.linkGraph?.orphans || []);
+  const headOrphans = new Set(headAudit.linkGraph?.orphans || []);
+  const newOrphans = [...headOrphans].filter((route) => !baseOrphans.has(route));
+  const resolvedOrphans = [...baseOrphans].filter((route) => !headOrphans.has(route));
+  const linkGraphDiff = {
+    newEdges,
+    removedEdges,
+    newOrphans,
+    resolvedOrphans
+  };
+  const baseSEOGraph = baseAudit.seoDependencyGraph || buildSEODependencyGraph(baseAudit.routes || [], { linkGraph: baseAudit.linkGraph });
+  const headSEOGraph = headAudit.seoDependencyGraph || buildSEODependencyGraph(headAudit.routes || [], {
+    linkGraph: headAudit.linkGraph,
+    inferredSemanticEdges: options.inferredSemanticEdges
+  });
+  const seoGraphDiff = computeGraphDiff(baseSEOGraph, headSEOGraph);
+  const newFindings = consolidateRegressionsByRootCause(
+    rawNewFindings,
+    baseAudit,
+    headAudit,
+    headSEOGraph,
+    seoGraphDiff
+  );
+  const affectedRoutesSet = /* @__PURE__ */ new Set();
+  for (const f of newFindings) {
+    if (f.route) affectedRoutesSet.add(f.route);
+    if (f.affectedRoutes) {
+      for (const r of f.affectedRoutes) affectedRoutesSet.add(r);
+    }
+  }
+  for (const orphan of newOrphans) {
+    affectedRoutesSet.add(orphan);
+  }
+  const affectedRoutes = Array.from(affectedRoutesSet).sort();
+  const qualityGate = evaluateQualityGate({
+    newFindings,
+    fixedFindings,
+    baselineDebt: baseFindings,
+    newOrphanRoutes: newOrphans,
+    affectedRoutes,
+    policy,
+    baselineTotalIssues
+  });
+  const scoreDiff = (headAudit.score?.overall ?? 0) - (baseAudit.score?.overall ?? 0);
+  const routesAtRisk = !qualityGate.passed ? affectedRoutes.length : 0;
+  const routesProtected = qualityGate.passed && fixedFindings.length > 0 ? affectedRoutes.length || fixedFindings.length : 0;
+  const preventionMetrics = {
+    prsAnalyzed: 1,
+    regressionsCaught: newFindings.length,
+    criticalRegressionsPrevented: qualityGate.summary.newCritical,
+    routesAtRisk,
+    routesProtected
+  };
+  return {
+    baseScore: baseAudit.score,
+    headScore: headAudit.score,
+    scoreDiff,
+    newFindings,
+    fixedFindings,
+    unchangedFindings,
+    linkGraphDiff,
+    seoGraphDiff,
+    affectedRoutes,
+    preventionMetrics,
+    qualityGate
+  };
+}
+
+// ../security/src/redactor.ts
+var SECRET_PATTERNS = [
+  /sk-[a-zA-Z0-9_-]{20,}/g,
+  // OpenAI, Anthropic, OpenRouter standard API keys
+  /ghp_[a-zA-Z0-9]{36,}/g,
+  // GitHub Personal Access Token
+  /ghs_[a-zA-Z0-9]{36,}/g,
+  // GitHub Installation Token
+  /github_pat_[a-zA-Z0-9_]{60,}/g,
+  // GitHub Fine-grained PAT
+  /Bearer\s+[a-zA-Z0-9._-]{20,}/gi,
+  // Bearer JWT or token
+  /-----BEGIN [A-Z ]+ PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+ PRIVATE KEY-----/g,
+  // RSA / EC Private Keys
+  /password\s*[:=]\s*["']?([^"' \n\r]+)["']?/gi,
+  // inline passwords
+  /secret\s*[:=]\s*["']?([^"' \n\r]+)["']?/gi
+  // inline secrets
+];
+function redactString(text) {
+  if (!text || typeof text !== "string") return text;
+  let redacted = text;
+  for (const pattern of SECRET_PATTERNS) {
+    redacted = redacted.replace(pattern, "[REDACTED_SECRET]");
+  }
+  return redacted;
+}
+function redactObject(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj === "string") return redactString(obj);
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => redactObject(item));
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const lowerKey = k.toLowerCase();
+    if (lowerKey.includes("key") || lowerKey.includes("secret") || lowerKey.includes("token") || lowerKey.includes("password") || lowerKey.includes("auth")) {
+      result[k] = "[REDACTED]";
+    } else {
+      result[k] = redactObject(v);
+    }
+  }
+  return result;
+}
+var secureLogger = {
+  info: (msg, ...args) => {
+    console.info(redactString(msg), ...args.map(redactObject));
+  },
+  warn: (msg, ...args) => {
+    console.warn(redactString(msg), ...args.map(redactObject));
+  },
+  error: (msg, ...args) => {
+    console.error(redactString(msg), ...args.map(redactObject));
+  }
+};
+
+// ../security/src/limiter.ts
+var RateLimiter = class {
+  entries = /* @__PURE__ */ new Map();
+  maxRequests;
+  windowMs;
+  constructor(maxRequests = 30, windowMs = 6e4) {
+    this.maxRequests = maxRequests;
+    this.windowMs = windowMs;
+  }
+  check(key) {
+    const now = Date.now();
+    const entry = this.entries.get(key) || { timestamps: [] };
+    const validTimestamps = entry.timestamps.filter((ts) => now - ts < this.windowMs);
+    if (validTimestamps.length >= this.maxRequests) {
+      const oldest = validTimestamps[0];
+      const resetMs = Math.max(0, this.windowMs - (now - oldest));
+      return {
+        allowed: false,
+        remaining: 0,
+        resetMs
+      };
+    }
+    validTimestamps.push(now);
+    this.entries.set(key, { timestamps: validTimestamps });
+    return {
+      allowed: true,
+      remaining: this.maxRequests - validTimestamps.length,
+      resetMs: this.windowMs
+    };
+  }
+  reset(key) {
+    this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+var globalRateLimiter = new RateLimiter(60, 6e4);
+
+// ../ai/src/provider.ts
+var CAPABILITY_BUDGETS = {
+  explain_finding: {
+    maxOutputTokens: 400,
+    temperature: 0.2,
+    timeoutMs: 12e3,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.01
+  },
+  detect_intent: {
+    maxOutputTokens: 300,
+    temperature: 0.1,
+    timeoutMs: 1e4,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.01
+  },
+  recommend_contract: {
+    maxOutputTokens: 800,
+    temperature: 0.2,
+    timeoutMs: 2e4,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.02
+  },
+  improve_title: {
+    maxOutputTokens: 250,
+    temperature: 0.3,
+    timeoutMs: 1e4,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.01
+  },
+  generate_description: {
+    maxOutputTokens: 300,
+    temperature: 0.3,
+    timeoutMs: 1e4,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.01
+  },
+  suggest_anchor: {
+    maxOutputTokens: 150,
+    temperature: 0.3,
+    timeoutMs: 8e3,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 5e-3
+  },
+  generate_brief: {
+    maxOutputTokens: 600,
+    temperature: 0.4,
+    timeoutMs: 15e3,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.02
+  },
+  resolve_semantic: {
+    maxOutputTokens: 1500,
+    temperature: 0.1,
+    timeoutMs: 35e3,
+    maxAttempts: 2,
+    maxEstimatedCostUsd: 0.05
+  },
+  explain_root_cause: {
+    maxOutputTokens: 800,
+    temperature: 0.2,
+    timeoutMs: 2e4,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.03
+  },
+  propose_fix: {
+    maxOutputTokens: 2500,
+    temperature: 0.1,
+    timeoutMs: 45e3,
+    maxAttempts: 1,
+    maxEstimatedCostUsd: 0.1
+  }
+};
+var OpenAICompatibleProvider = class {
+  apiKey;
+  baseUrl;
+  model;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl || "https://api.openai.com/v1";
+    this.model = options.model || "gpt-4o-mini";
+  }
+  async execute(request) {
+    const budget = CAPABILITY_BUDGETS[request.action] || {
+      maxOutputTokens: 1e3,
+      temperature: 0.2,
+      timeoutMs: 2e4,
+      maxAttempts: 1,
+      maxEstimatedCostUsd: 0.02
+    };
+    const isReasoningModel = this.model.includes("deepseek") || this.model.includes("o1") || this.model.includes("o3");
+    const allocatedMaxTokens = isReasoningModel ? Math.max(budget.maxOutputTokens, 3e3) : budget.maxOutputTokens;
+    const prompt = this.buildPrompt(request);
+    const startTime = Date.now();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), budget.timeoutMs);
+    try {
+      const res = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          "User-Agent": "Crawlemon-AI"
+        },
+        signal: controller.signal,
+        body: JSON.stringify({
+          model: this.model,
+          messages: [
+            {
+              role: "system",
+              content: "You are an expert technical SEO and verification assistant. Keep answers precise, punchy, and developer-friendly. Do not include markdown code block quotes around the primary text suggestion."
+            },
+            {
+              role: "user",
+              content: prompt
+            }
+          ],
+          temperature: budget.temperature,
+          max_tokens: allocatedMaxTokens
+        })
+      });
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        const errText = await res.text();
+        secureLogger.error(`AI provider call failed: ${res.status}`);
+        throw new Error(`AI Provider HTTP ${res.status}: ${redactString(errText)}`);
+      }
+      const latencyMs = Date.now() - startTime;
+      const data = await res.json();
+      const output = data.choices?.[0]?.message?.content?.trim() || "";
+      const inputTokens = data.usage?.prompt_tokens ?? 0;
+      const outputTokens = data.usage?.completion_tokens ?? 0;
+      const estimatedCostUsd = Number((inputTokens * 14e-8 + outputTokens * 28e-8).toFixed(6));
+      const telemetry = {
+        provider: "openai-compatible",
+        model: this.model,
+        latencyMs,
+        inputTokens,
+        outputTokens,
+        estimatedCostUsd
+      };
+      const formatted = this.formatResponse(request, output);
+      return {
+        ...formatted,
+        telemetry
+      };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      secureLogger.error("Error executing AI request", err);
+      throw new Error(`Failed to generate AI suggestion: ${err?.message || err}`);
+    }
+  }
+  buildPrompt(request) {
+    const { action, context } = request;
+    switch (action) {
+      case "improve_title":
+        return redactString(
+          `Improve this SEO title for route "${context.route}":
+Current title: "${context.currentTitle || "Untitled"}"
+Keywords: ${context.keywords?.join(", ") || "none"}
+Return a compelling, click-worthy title between 40 and 60 characters.`
+        );
+      case "generate_description":
+        return redactString(
+          `Write a high-CTR meta description for route "${context.route}".
+Page context / title: "${context.currentTitle || ""}"
+Keywords: ${context.keywords?.join(", ") || "none"}
+Length must be strictly between 120 and 155 characters.`
+        );
+      case "explain_finding":
+        return redactString(
+          `Explain this SEO finding to a developer in simple terms and why fixing it matters:
+Issue: "${context.findingMessage}"
+Route: "${context.route}"`
+        );
+      case "suggest_anchor":
+        return redactString(
+          `Suggest natural, context-rich anchor text for an internal link pointing to "${context.route}".
+Topic keywords: ${context.keywords?.join(", ") || ""}`
+        );
+      case "generate_brief":
+        return redactString(
+          `Generate a concise developer content brief for a new page at route "${context.route}".
+Cluster topic: "${context.clusterTopic || ""}".
+Include suggested H1, 3 key H2 sections, and target search intent.`
+        );
+      case "resolve_semantic":
+        return redactString(
+          `Analyze this SEO helper code and identify what metadata properties it sets:
+Helper Name: "${context.helperName || ""}"
+File: "${context.filePath || ""}"
+Helper Source:
+\`\`\`ts
+${context.helperCode || ""}
+\`\`\`
+Page Call Site:
+\`\`\`ts
+${context.sourceCode || ""}
+\`\`\`
+Respond ONLY with a valid JSON object matching this structure:
+{
+  "helperName": "${context.helperName || ""}",
+  "confidence": 0.85,
+  "maps": {
+    "canonical": "expression or field",
+    "robots": "expression or field",
+    "title": "expression or field",
+    "description": "expression or field"
+  },
+  "evidenceChain": ["file.ts: helper function", "builds alternates.canonical"]
+}`
+        );
+      case "explain_root_cause":
+        return redactString(
+          `Explain why this SEO regression happened and how it propagated downstream.
+Issue: "${context.findingMessage || ""}"
+File: "${context.filePath || ""}"
+Affected Routes (${context.regressionContext?.blastRadiusRoutes?.length || 0}): ${context.regressionContext?.blastRadiusRoutes?.slice(0, 5).join(", ") || "none"}
+Diff context:
+${context.regressionContext?.diffSnippet || ""}
+Keep the explanation to 2-3 clear, professional developer-centric sentences.`
+        );
+      case "propose_fix": {
+        const headContent = context.regressionContext?.headFileContent || context.sourceCode || "";
+        const baseContent = context.regressionContext?.baseFileContent || "";
+        return redactString(
+          `Propose a minimal, safe code fix for this SEO regression:
+File: "${context.filePath}"
+Regression: "${context.findingMessage}"
+Current code:
+\`\`\`ts
+${headContent}
+\`\`\`
+Base (working) code:
+\`\`\`ts
+${baseContent}
+\`\`\`
+Respond with a valid JSON object:
+{
+  "filePath": "${context.filePath}",
+  "patch": "unified diff or replacement block",
+  "explanation": "Why this fixes the regression",
+  "replacementCode": "exact full new file content or minimal replacement"
+}`
+        );
+      }
+      case "detect_intent":
+        return redactString(
+          `Analyze whether this SEO directive change (e.g. noindex or canonical removal) was likely intentional by the developer.
+Route: "${context.route}"
+Directive: "${context.findingMessage}"
+Page Snippet:
+${context.sourceCode || ""}
+Respond with a JSON object:
+{
+  "route": "${context.route}",
+  "likelyIntentional": true/false,
+  "confidence": 0.85,
+  "reasoning": "short reasoning",
+  "suggestedAction": "allow_policy" | "keep_blocking" | "manual_review"
+}`
+        );
+      case "recommend_contract":
+        return redactString(
+          `Analyze these discovered routes and recommend 1 or 2 strict SEO Contracts for policy enforcement:
+Routes sample:
+${(context.candidateRoutes || []).map((r) => `${r.route} (title=${r.metadata?.title ? "yes" : "no"}, canonical=${r.metadata?.canonical ? "yes" : "no"}, robots=${r.metadata?.robots || "index"})`).slice(0, 15).join("\n")}
+Respond with a JSON object:
+{
+  "suggestedContracts": [
+    {
+      "name": "contract-name",
+      "routes": ["/pattern/**"],
+      "requirement": { "indexable": true, "canonical": "required" }
+    }
+  ],
+  "explanation": "reasoning"
+}`
+        );
+      default:
+        return "Improve this SEO attribute.";
+    }
+  }
+  formatResponse(request, rawText) {
+    const { action, context } = request;
+    if (action === "improve_title") {
+      const clean = rawText.replace(/^["']|["']$/g, "").trim();
+      return {
+        suggestion: clean,
+        explanation: "Generated based on target route keywords and 50-60 char SERP best practices.",
+        diffPreview: `- title: "${context.currentTitle || ""}"
++ title: "${clean}"`
+      };
+    }
+    if (action === "generate_description") {
+      const clean = rawText.replace(/^["']|["']$/g, "").trim();
+      return {
+        suggestion: clean,
+        explanation: `Recommended meta description (${clean.length} chars) optimized for SERP click-through rate.`,
+        diffPreview: `- description: "${context.currentDescription || ""}"
++ description: "${clean}"`
+      };
+    }
+    if (action === "resolve_semantic") {
+      try {
+        const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+        const parsed = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+        if (parsed) {
+          return {
+            suggestion: `Inferred metadata helper ${parsed.helperName}`,
+            explanation: `Identified semantic mapping with confidence ${parsed.confidence || 0.8}`,
+            semanticResolution: {
+              helperName: parsed.helperName || context.helperName || "customHelper",
+              inferredSourceFile: parsed.inferredSourceFile || context.filePath,
+              confidence: parsed.confidence || 0.8,
+              maps: parsed.maps || {},
+              evidenceChain: parsed.evidenceChain || [context.filePath || "unknown"]
+            }
+          };
+        }
+      } catch {
+      }
+      return {
+        suggestion: rawText,
+        explanation: "Raw semantic inference"
+      };
+    }
+    if (action === "explain_root_cause") {
+      return {
+        suggestion: rawText,
+        explanation: "Root cause synthesis based on git diff and dependency graph blast radius."
+      };
+    }
+    if (action === "propose_fix") {
+      try {
+        const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+        const parsed = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+        if (parsed) {
+          return {
+            suggestion: parsed.explanation || "AI Proposed Fix",
+            explanation: parsed.explanation,
+            diffPreview: parsed.patch,
+            fixProposal: {
+              filePath: parsed.filePath || context.filePath || "",
+              patch: parsed.patch || rawText,
+              explanation: parsed.explanation || "",
+              resolvedFindings: [context.findingMessage || ""]
+            }
+          };
+        }
+      } catch {
+      }
+      return {
+        suggestion: rawText,
+        explanation: "AI Proposed Patch",
+        diffPreview: rawText
+      };
+    }
+    if (action === "detect_intent") {
+      try {
+        const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+        const parsed = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+        if (parsed) {
+          return {
+            suggestion: parsed.likelyIntentional ? "Likely intentional" : "Likely accidental regression",
+            explanation: parsed.reasoning,
+            intentDetection: parsed
+          };
+        }
+      } catch {
+      }
+      return {
+        suggestion: rawText,
+        explanation: "Intent detection analysis"
+      };
+    }
+    if (action === "recommend_contract") {
+      try {
+        const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+        const parsed = jsonMatch ? JSON.parse(jsonMatch[0]) : null;
+        if (parsed && Array.isArray(parsed.suggestedContracts)) {
+          return {
+            suggestion: `Suggested ${parsed.suggestedContracts.length} SEO contract(s)`,
+            explanation: parsed.explanation,
+            contractRecommendation: parsed
+          };
+        }
+      } catch {
+      }
+      return {
+        suggestion: rawText,
+        explanation: "Contract recommendation analysis"
+      };
+    }
+    return {
+      suggestion: rawText,
+      explanation: "AI generated suggestion. Review and approve before applying."
+    };
+  }
+};
+function hasAIKey(options) {
+  if (options?.enabled === false) return false;
+  if (options?.apiKey && options.apiKey.trim().length > 0) return true;
+  const envKey = process.env.DEEPSEEK_API_KEY || process.env.CRAWLEMON_AI_KEY || process.env.OPENAI_API_KEY || process.env.AI_API_KEY;
+  return Boolean(envKey && envKey.trim().length > 0);
+}
+function getActiveAIProvider(options) {
+  if (options?.enabled === false) return null;
+  const isDeepSeek = Boolean(process.env.DEEPSEEK_API_KEY && !options?.apiKey && !process.env.CRAWLEMON_AI_KEY && !process.env.OPENAI_API_KEY);
+  const key = options?.apiKey || process.env.DEEPSEEK_API_KEY || process.env.CRAWLEMON_AI_KEY || process.env.OPENAI_API_KEY || process.env.AI_API_KEY;
+  if (!key || key.trim() === "") return null;
+  const defaultBaseUrl = isDeepSeek ? "https://api.deepseek.com" : "https://api.openai.com/v1";
+  const defaultModel = isDeepSeek ? process.env.DEEPSEEK_MODEL || "deepseek-v4-flash" : "gpt-4o-mini";
+  return new OpenAICompatibleProvider({
+    apiKey: key.trim(),
+    baseUrl: options?.baseUrl || process.env.DEEPSEEK_BASE_URL || process.env.CRAWLEMON_AI_BASE_URL || process.env.OPENAI_BASE_URL || process.env.AI_BASE_URL || defaultBaseUrl,
+    model: options?.model || process.env.DEEPSEEK_MODEL || process.env.CRAWLEMON_AI_MODEL || process.env.OPENAI_MODEL || process.env.AI_MODEL || defaultModel
+  });
+}
+var SessionKeyStore = class {
+  store = /* @__PURE__ */ new Map();
+  set(sessionId, key, provider = "openai", ttlMs = 15 * 60 * 1e3) {
+    this.store.set(sessionId, {
+      key,
+      provider,
+      expiresAt: Date.now() + ttlMs
+    });
+  }
+  get(sessionId) {
+    const entry = this.store.get(sessionId);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(sessionId);
+      return null;
+    }
+    return { key: entry.key, provider: entry.provider };
+  }
+  delete(sessionId) {
+    this.store.delete(sessionId);
+  }
+};
+var sessionKeyStore = new SessionKeyStore();
+
+// ../ai/src/semantic-resolver.ts
+import fs5 from "node:fs";
+import path6 from "node:path";
+var METADATA_KEYS = ["canonical", "robots", "title", "description"];
+function helperDefinesProperty(helperCode, property) {
+  const escaped = property.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?:^|[,{;\\s])(?:["']${escaped}["']|${escaped})\\s*:`, "m").test(helperCode);
+}
+async function resolveSemanticHelpers(options) {
+  const { projectRoot, routes, aiProvider } = options;
+  if (!aiProvider) return [];
+  const results = [];
+  for (const route of routes) {
+    if (!route.filePath || !fs5.existsSync(route.filePath)) continue;
+    const content = fs5.readFileSync(route.filePath, "utf8");
+    const helperMatch = content.match(
+      /export\s+const\s+metadata\s*=\s*([A-Za-z0-9_]+)\s*\(([\s\S]*?)\)/
+    );
+    if (!helperMatch) continue;
+    const helperName = helperMatch[1];
+    if (["generateMetadata", "fetch", "Promise"].includes(helperName)) continue;
+    const importMatch = content.match(
+      new RegExp(`import\\s*\\{[^}]*\\b${helperName}\\b[^}]*\\}\\s*from\\s*["']([^"']+)["']`)
+    );
+    let helperFilePath;
+    let helperCode;
+    if (importMatch) {
+      const importPath = importMatch[1];
+      const candidates = [
+        path6.resolve(path6.dirname(route.filePath), `${importPath}.ts`),
+        path6.resolve(path6.dirname(route.filePath), `${importPath}.tsx`),
+        path6.resolve(path6.dirname(route.filePath), `${importPath}/index.ts`),
+        path6.resolve(projectRoot, `${importPath.replace(/^@\//, "src/").replace(/^~\//, "")}.ts`),
+        path6.resolve(projectRoot, `${importPath.replace(/^@\//, "src/").replace(/^~\//, "")}.tsx`)
+      ];
+      for (const cand of candidates) {
+        if (fs5.existsSync(cand)) {
+          helperFilePath = cand;
+          helperCode = fs5.readFileSync(cand, "utf8");
+          break;
+        }
+      }
+    }
+    try {
+      const res = await aiProvider.execute({
+        action: "resolve_semantic",
+        context: {
+          route: route.route,
+          filePath: route.filePath,
+          helperName,
+          helperCode: helperCode?.slice(0, 1500) || "// Helper source not statically resolved",
+          sourceCode: helperMatch[0]
+        }
+      });
+      const resolution = res.semanticResolution;
+      if (!resolution) continue;
+      const helperVerified = Boolean(helperFilePath && helperCode);
+      const hasMeaningfulProps = Boolean(
+        resolution.maps.canonical || resolution.maps.robots || resolution.maps.title || resolution.maps.description
+      );
+      if (hasMeaningfulProps) {
+        const verifiedProperties = helperCode ? METADATA_KEYS.filter((property) => resolution.maps[property] && helperDefinesProperty(helperCode, property)) : [];
+        const confidence = verifiedProperties.length > 0 ? "AI_VERIFIED" : "AI_ASSISTED";
+        const cleanHelperPath = helperFilePath ? path6.relative(projectRoot, helperFilePath).replace(/\\/g, "/") : helperName;
+        const resolvedMeta = {};
+        if (verifiedProperties.includes("canonical") && !route.metadata?.canonical) {
+          resolvedMeta.canonical = resolution.maps.canonical;
+        }
+        if (verifiedProperties.includes("robots") && !route.metadata?.robots) {
+          resolvedMeta.robots = resolution.maps.robots;
+        }
+        const proofId = `proof-seo-${path6.basename(route.filePath)}-${helperName}`;
+        const evidenceItems = [
+          {
+            id: `ev-callsite-${helperName}`,
+            kind: "CALL_EDGE",
+            source: { file: route.filePath, route: route.route, symbol: helperName },
+            description: `Call site in page file invokes ${helperName}`,
+            value: helperMatch[0]
+          }
+        ];
+        if (helperVerified) {
+          evidenceItems.push({
+            id: `ev-def-${helperName}`,
+            kind: "AST_NODE",
+            source: { file: cleanHelperPath, symbol: helperName },
+            description: `Helper source definition verified on filesystem`,
+            value: helperCode?.slice(0, 300)
+          });
+        }
+        const verifiedClaims = [];
+        const rejectedClaims = [];
+        for (const [prop, val] of Object.entries(resolution.maps)) {
+          if (val) {
+            if (helperVerified && verifiedProperties.includes(prop)) {
+              verifiedClaims.push({
+                id: `claim-${prop}-${helperName}`,
+                subject: route.route,
+                predicate: `has${prop.charAt(0).toUpperCase() + prop.slice(1)}`,
+                observedValue: val,
+                evidenceRefs: evidenceItems.map((e) => e.id),
+                source: { file: cleanHelperPath, route: route.route }
+              });
+            } else {
+              rejectedClaims.push({
+                id: `claim-${prop}-${helperName}`,
+                subject: route.route,
+                predicate: `has${prop.charAt(0).toUpperCase() + prop.slice(1)}`,
+                reason: helperVerified ? `Helper source does not deterministically define metadata property "${prop}".` : "Helper source code could not be verified on filesystem."
+              });
+            }
+          }
+        }
+        const proof = {
+          id: proofId,
+          hypothesisId: `hypo-${helperName}`,
+          domain: "seo",
+          discoveredBy: "AI",
+          verifier: verifiedProperties.length > 0 ? "DETERMINISTIC_VERIFIER" : "UNVERIFIED_HEURISTIC",
+          confidence: verifiedProperties.length > 0 ? "AI_VERIFIED" : "AI_ASSISTED",
+          evidence: evidenceItems,
+          verifiedClaims,
+          rejectedClaims,
+          telemetry: res.telemetry
+        };
+        const edge = {
+          source: `file:${route.filePath}`,
+          target: `helper:${cleanHelperPath}`,
+          type: "INFERRED_SEMANTIC_EDGE",
+          detail: `${helperName} maps: ${Object.keys(resolution.maps).filter((k) => resolution.maps[k]).join(", ")}`,
+          confidence,
+          proof,
+          provenance: {
+            discoveredBy: "AI",
+            verifiedBy: verifiedProperties.length > 0 ? "DETERMINISTIC_VERIFIER" : void 0,
+            evidence: [
+              `Call site: ${path6.basename(route.filePath)}`,
+              helperVerified ? `Helper definition: ${cleanHelperPath}` : `Inferred signature from ${helperName}`,
+              ...resolution.evidenceChain || []
+            ]
+          }
+        };
+        results.push({
+          route: route.route,
+          helperName,
+          sourceFile: route.filePath,
+          resolvedMetadata: resolvedMeta,
+          confidence,
+          evidence: edge.provenance?.evidence || [],
+          edge
+        });
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+
+// src/formatter.ts
+import path7 from "node:path";
+var colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m"
+};
+function printQualityGateReport(diff, baseRef, headRef, options = {}) {
+  if (options.json) {
+    console.log(JSON.stringify(diff, null, 2));
+    return;
+  }
+  const { qualityGate, newFindings, fixedFindings, unchangedFindings, affectedRoutes, preventionMetrics } = diff;
+  const projectRoot = options.projectRoot || process.cwd();
+  console.log(`
+\u{1F34B} ${colors.bold}Crawlemon SEO Gate${colors.reset}
+`);
+  const gateStatusText = qualityGate.passed ? `${colors.green}${colors.bold}PASSED${colors.reset}` : `${colors.red}${colors.bold}FAILED${colors.reset}`;
+  console.log(`${gateStatusText}
+`);
+  console.log(`Comparing:
+${colors.cyan}${baseRef}...${headRef}${colors.reset}
+`);
+  const summary = qualityGate.summary;
+  const regressionCount = summary.newCritical + summary.newErrors;
+  console.log(
+    `${regressionCount > 0 ? colors.red : colors.green}${regressionCount} new regression(s) across ${affectedRoutes.length} affected route(s)${colors.reset}
+${summary.newWarnings > 0 ? colors.yellow : colors.dim}${summary.newWarnings} new warning(s)${colors.reset}
+${colors.green}${summary.fixedFindings} issue(s) fixed${colors.reset}`
+  );
+  if (preventionMetrics) {
+    if (preventionMetrics.routesAtRisk > 0) {
+      console.log(`${colors.yellow}\u26A0\uFE0F  ${preventionMetrics.routesAtRisk} route(s) at risk${colors.reset}`);
+    }
+    if (preventionMetrics.routesProtected > 0) {
+      console.log(`${colors.green}${colors.bold}\u{1F6E1}\uFE0F  ${preventionMetrics.routesProtected} route(s) protected${colors.reset}`);
+    }
+  }
+  console.log(`
+${colors.dim}${"\u2501".repeat(45)}${colors.reset}
+`);
+  if (newFindings.length > 0) {
+    for (const f of newFindings) {
+      const isCritical = f.severity === "error";
+      const titleColor = isCritical ? colors.red : colors.yellow;
+      console.log(`${titleColor}${colors.bold}${f.message}${colors.reset}`);
+      console.log(`${colors.dim}${"\u2501".repeat(45)}${colors.reset}
+`);
+      const rawFile = f.rootCause?.file || f.sourceFile || f.file || "";
+      const relFile = rawFile ? path7.relative(projectRoot, rawFile).replace(/\\/g, "/") : "";
+      const lineSuffix = f.rootCause?.line || f.sourceLine || f.line ? `:${f.rootCause?.line || f.sourceLine || f.line}` : "";
+      if (f.rootCause) {
+        console.log(`${colors.bold}Root cause${colors.reset}`);
+        console.log(`${colors.cyan}${relFile}${lineSuffix}${colors.reset}`);
+        if (f.rootCause.changeDescription) {
+          console.log(`${colors.dim}${f.rootCause.changeDescription}${colors.reset}`);
+        }
+        console.log();
+      } else if (relFile) {
+        console.log(`${colors.bold}Source${colors.reset}`);
+        console.log(`${colors.cyan}${relFile}${lineSuffix}${colors.reset}
+`);
+      }
+      if (f.evidenceChain?.whyThisHappened || f.explanation) {
+        console.log(`${colors.bold}Why this happened${colors.reset}`);
+        console.log(`${f.evidenceChain?.whyThisHappened || f.explanation}
+`);
+      }
+      if (f.evidenceChain?.steps && f.evidenceChain.steps.length > 0) {
+        console.log(`${colors.bold}Dependency${colors.reset}`);
+        const sourceName = path7.basename(relFile || f.evidenceChain.sourceFile);
+        console.log(`${sourceName}`);
+        for (const step of f.evidenceChain.steps) {
+          const detail = step.detail ? ` ${step.detail}` : "";
+          console.log(`   ${colors.dim}\u2193${detail}${colors.reset}`);
+          console.log(`${step.to}`);
+        }
+        if (f.affectedRoutes && f.affectedRoutes.length > 1) {
+          console.log(`   ${colors.dim}\u2193${colors.reset}`);
+          console.log(`${f.affectedRoutes.length} known routes`);
+        }
+        console.log();
+      }
+      if (f.impact && f.impact.targets.length > 0) {
+        console.log(`${colors.bold}Impact${colors.reset}`);
+        console.log(`${f.impact.totalAffected} target(s) affected (${f.impact.targets[0]?.type || "symbol/entity"})`);
+        if (f.impact.description) {
+          console.log(`${colors.dim}${f.impact.description}${colors.reset}`);
+        }
+        console.log(`
+${colors.bold}Examples${colors.reset}`);
+        for (const t of f.impact.targets.slice(0, 3)) {
+          const location = t.source?.file ? ` (${t.source.file}${t.source.line ? `:${t.source.line}` : ""})` : "";
+          console.log(`${colors.dim}${t.label}${location}${colors.reset}`);
+        }
+        if (f.impact.targets.length > 3) {
+          console.log(`${colors.dim}...and ${f.impact.targets.length - 3} more target(s)${colors.reset}`);
+        }
+        console.log();
+      } else {
+        const routeList = f.affectedRoutes?.length ? f.affectedRoutes : f.route ? [f.route] : [];
+        if (routeList.length > 0) {
+          console.log(`${colors.bold}Impact${colors.reset}`);
+          console.log(`${routeList.length} known route(s) affected`);
+          if (f.routePattern) {
+            console.log(`Pattern: ${f.routePattern}`);
+          }
+          console.log(`
+${colors.bold}Examples${colors.reset}`);
+          for (const r of routeList.slice(0, 3)) {
+            console.log(`${colors.dim}${r}${colors.reset}`);
+          }
+          if (routeList.length > 3) {
+            console.log(`${colors.dim}...and ${routeList.length - 3} more routes${colors.reset}`);
+          }
+          console.log();
+        }
+      }
+      console.log(`${colors.bold}Confidence${colors.reset}`);
+      let confBadge = `${colors.bold}${colors.cyan}${f.confidence || "DETERMINISTIC"}${colors.reset}`;
+      if (f.confidence === "AI_VERIFIED") {
+        confBadge = `${colors.bold}${colors.green}\u2713 AI_VERIFIED (Proven by Deterministic Verifier)${colors.reset}`;
+      } else if (f.confidence === "AI_ASSISTED") {
+        confBadge = `${colors.bold}${colors.yellow}\u2139 AI_ASSISTED (Non-blocking hypothesis)${colors.reset}`;
+      } else if (f.confidence === "STRUCTURAL") {
+        confBadge = `${colors.bold}${colors.blue}STRUCTURAL (Inherited / Blast Radius)${colors.reset}`;
+      } else if (f.confidence === "DETERMINISTIC") {
+        confBadge = `${colors.bold}${colors.cyan}DETERMINISTIC (Zero-hallucination AST Proof)${colors.reset}`;
+      }
+      console.log(`${confBadge}
+`);
+      if (f.fixability === "VERIFIED_AI_FIX") {
+        console.log(`${colors.bold}Fix${colors.reset}`);
+        console.log(`${colors.green}\u2713 Verified AI Fix${colors.reset} (Re-verified in sandbox, 0 regressions)`);
+        console.log(`${f.evidenceChain?.fixRecommendation || "Apply verified patch."}
+`);
+      } else if (f.fixability === "REVERT_SAFE" || f.evidenceChain?.revertSafeValue) {
+        console.log(`${colors.bold}Fix${colors.reset}`);
+        console.log(`${f.evidenceChain?.fixRecommendation || "Restore previous declaration from BASE."}`);
+        console.log(`${colors.green}[Preview Revert-Safe Fix]${colors.reset}
+`);
+      } else if (f.fixable) {
+        console.log(`${colors.bold}Fix${colors.reset}`);
+        console.log(`Deterministic fix available via \`npx crawlemon fix\`
+`);
+      }
+      console.log(`${colors.dim}${"\u2501".repeat(45)}${colors.reset}
+`);
+    }
+  }
+  if (summary.baselineTotalIssues > 0) {
+    console.log(`${colors.bold}Existing baseline debt${colors.reset}`);
+    console.log(`${summary.baselineTotalIssues} pre-existing finding(s)
+${colors.dim}Ignored for this gate (Clean-As-You-Code).${colors.reset}
+`);
+    console.log(`${colors.dim}${"\u2501".repeat(45)}${colors.reset}
+`);
+  }
+  const gateBadge = qualityGate.passed ? `${colors.bgGreen}${colors.bold} SEO Gate: PASSED ${colors.reset}` : `${colors.bgRed}${colors.bold} SEO Gate: FAILED ${colors.reset}`;
+  console.log(gateBadge + "\n");
+}
+function formatScoreBadge(score) {
+  if (score >= 85) return `${colors.green}${colors.bold}${score}/100${colors.reset}`;
+  if (score >= 70) return `${colors.yellow}${colors.bold}${score}/100${colors.reset}`;
+  return `${colors.red}${colors.bold}${score}/100${colors.reset}`;
+}
+function printAuditReport(result, projectRoot) {
+  const { score, findings, routes } = result;
+  console.log("\n" + colors.cyan + colors.bold + "\u{1F50D} Crawlemon Audit" + colors.reset + ` (${routes.length} routes scanned)`);
+  console.log(colors.dim + "\u2500".repeat(50) + colors.reset);
+  console.log(`
+  SEO Score: ${formatScoreBadge(score.overall)}`);
+  console.log(`  ${colors.dim}Technical:     ${score.breakdown.technical.toString().padEnd(4)} Metadata:       ${score.breakdown.metadata}`);
+  console.log(`  Content:       ${score.breakdown.content.toString().padEnd(4)} Internal Links: ${score.breakdown.links}${colors.reset}
+`);
+  if (findings.length === 0) {
+    console.log(`${colors.green}\u2713 All checks passed! No SEO regressions or issues found.${colors.reset}
+`);
+    return;
   }
   const errors = findings.filter((f) => f.severity === "error");
   const warnings = findings.filter((f) => f.severity === "warning");
@@ -1811,7 +4165,7 @@ function printAuditReport(result, projectRoot) {
     if (f.severity === "warning") icon = colors.yellow + "\u26A0" + colors.reset;
     const fixTag = f.fixable ? ` ${colors.green}[fixable]${colors.reset}` : "";
     const routeTag = f.route ? ` ${colors.cyan}(${f.route})${colors.reset}` : "";
-    const relativeFile = f.file ? path3.relative(projectRoot, f.file) : "";
+    const relativeFile = f.file ? path7.relative(projectRoot, f.file) : "";
     const fileTag = relativeFile ? `
     ${colors.dim}${relativeFile}${f.line ? `:${f.line}` : ""}${colors.reset}` : "";
     console.log(`  ${icon} ${f.message}${fixTag}${routeTag}${fileTag}`);
@@ -1903,16 +4257,55 @@ ${colors.bold}Cluster: ${c.topic}${colors.reset} (${colors.dim}${c.pattern}${col
 }
 
 // src/index.ts
+function loadLocalEnv(projectRoot) {
+  const dirsToSearch = [projectRoot];
+  let curr = projectRoot;
+  for (let i = 0; i < 4; i++) {
+    const parent = path8.dirname(curr);
+    if (parent && parent !== curr) {
+      dirsToSearch.push(parent);
+      curr = parent;
+    } else {
+      break;
+    }
+  }
+  for (const dir of dirsToSearch) {
+    for (const envFile of [".env", ".env.local"]) {
+      const fullPath = path8.join(dir, envFile);
+      if (fs6.existsSync(fullPath)) {
+        try {
+          const content = fs6.readFileSync(fullPath, "utf8");
+          for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx !== -1) {
+              const key = trimmed.slice(0, eqIdx).trim();
+              let val = trimmed.slice(eqIdx + 1).trim();
+              if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+                val = val.slice(1, -1);
+              }
+              if (process.env[key] === void 0) {
+                process.env[key] = val;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+}
 function checkSecretRisk(projectRoot) {
-  const envCandidates = fs3.readdirSync(projectRoot).filter((name) => name !== ".env.example" && (name === ".env" || name.startsWith(".env.")));
-  const gitignorePath = path4.join(projectRoot, ".gitignore");
+  const envCandidates = fs6.readdirSync(projectRoot).filter((name) => name !== ".env.example" && (name === ".env" || name.startsWith(".env.")));
+  const gitignorePath = path8.join(projectRoot, ".gitignore");
   let gitignoreContent = "";
-  if (fs3.existsSync(gitignorePath)) {
-    gitignoreContent = fs3.readFileSync(gitignorePath, "utf8");
+  if (fs6.existsSync(gitignorePath)) {
+    gitignoreContent = fs6.readFileSync(gitignorePath, "utf8");
   }
   for (const env of envCandidates) {
-    const envPath = path4.join(projectRoot, env);
-    if (fs3.existsSync(envPath)) {
+    const envPath = path8.join(projectRoot, env);
+    if (fs6.existsSync(envPath)) {
       const tracked = spawnSync("git", ["ls-files", "--error-unmatch", "--", env], {
         cwd: projectRoot,
         stdio: "ignore"
@@ -1923,24 +4316,65 @@ function checkSecretRisk(projectRoot) {
     }
   }
 }
+async function auditGitRef(projectRoot, ref) {
+  const tmpDir = fs6.mkdtempSync(path8.join(os.tmpdir(), "crawlemon-base-"));
+  try {
+    const gitRootRes = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: projectRoot, encoding: "utf8" });
+    const gitRoot = gitRootRes.status === 0 ? gitRootRes.stdout.trim() : projectRoot;
+    const relToGitRoot = path8.relative(gitRoot, projectRoot).replace(/\\/g, "/");
+    const archiveRef = relToGitRoot && relToGitRoot !== "." ? `${ref}:${relToGitRoot}` : ref;
+    const gitArchive = spawnSync("git", ["archive", archiveRef], {
+      cwd: gitRoot,
+      maxBuffer: 64 * 1024 * 1024
+    });
+    if (gitArchive.status !== 0 || !gitArchive.stdout) {
+      throw new Error(`Failed to read git ref "${ref}": ${gitArchive.stderr?.toString() || "ref not found"}`);
+    }
+    const tar = spawnSync("tar", ["-x", "-C", tmpDir], { input: gitArchive.stdout });
+    if (tar.status !== 0) {
+      throw new Error(`Failed to extract git archive for "${ref}".`);
+    }
+    const scanData = await FrameworkAdapter.scan(tmpDir);
+    return runSEOAudit({
+      routes: scanData.routes,
+      config: scanData.config,
+      sitemapFound: scanData.sitemapFound,
+      robotsFound: scanData.robotsFound,
+      robotsContent: scanData.robotsContent,
+      sitemapUrls: scanData.sitemapUrls,
+      sitemapMalformed: scanData.sitemapMalformed,
+      redirects: scanData.redirects,
+      projectRoot: scanData.projectRoot,
+      isAppRouter: scanData.isAppRouter
+    });
+  } finally {
+    fs6.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
 async function runCli(args) {
   const command = args[0] || "audit";
   const projectRoot = process.cwd();
+  const isJson = args.includes("--json");
+  const baseFlagIndex = args.indexOf("--base");
+  const baseRefArg = baseFlagIndex !== -1 && args[baseFlagIndex + 1] ? args[baseFlagIndex + 1] : void 0;
   if (command === "--help" || command === "help") {
-    console.log("Crawlemon \u2014 deterministic SEO CI for Next.js\n\nCommands:\n  audit\n  fix [--dry-run]\n  links\n  opportunities");
+    console.log(
+      "Crawlemon \u2014 SEO CI for modern web apps\nThe SEO safety layer between code and production.\n\nCommands:\n  diff [--base <ref>] [--ai] [--json] Compare code change vs base ref and evaluate Quality Gate\n  audit [--base <ref>] [--ai] [--json] Audit current routes or compare against base ref\n  fix [--dry-run]                     Apply safe deterministic SEO fixes\n  contract suggest                    (AI/Pattern) Propose strict SEO Contracts from codebase\n  links                               Inspect internal link graph and orphans\n  opportunities                       (Labs) Inspect topic expansion clusters\n\nOptions:\n  --ai                                Enable AI semantic resolver & root-cause analysis (auto-fallback if no key)\n"
+    );
     return;
   }
   if (command === "--version" || command === "-v") {
-    console.log("0.1.0");
+    console.log("0.2.0");
     return;
   }
   checkSecretRisk(projectRoot);
-  const isNext = await NextJsAdapter.detect(projectRoot);
-  if (!isNext) {
-    console.error(`\x1B[31m\u2716 Error: No Next.js application detected in "${projectRoot}".\x1B[0m`);
+  loadLocalEnv(projectRoot);
+  const framework = await FrameworkAdapter.detect(projectRoot);
+  if (!framework) {
+    console.error(`\x1B[31m\u2716 Error: No supported web framework detected in "${projectRoot}".\x1B[0m`);
     process.exit(1);
   }
-  const scanData = await NextJsAdapter.scan(projectRoot);
+  const scanData = await FrameworkAdapter.scan(projectRoot);
   const auditResult = runSEOAudit({
     routes: scanData.routes,
     config: scanData.config,
@@ -1953,7 +4387,70 @@ async function runCli(args) {
     projectRoot: scanData.projectRoot,
     isAppRouter: scanData.isAppRouter
   });
+  if (scanData.dependencyGraph) {
+    for (const f of auditResult.findings) {
+      if (f.file && f.file.includes("layout.")) {
+        const impact = scanData.dependencyGraph.calculateBlastRadius(f.file);
+        f.affectedRoutes = impact.affectedRoutes;
+        f.routePattern = impact.routePattern;
+      }
+    }
+  }
+  const useAI = args.includes("--ai");
+  const aiKeyAvailable = hasAIKey();
+  const aiProvider = useAI || aiKeyAvailable ? getActiveAIProvider() : null;
+  if (useAI && !aiKeyAvailable) {
+    console.log(`\x1B[2m\u2139 Note: AI flag specified but no API key configured. Automatically executing in 100% deterministic mode.\x1B[0m
+`);
+  }
+  let inferredSemanticEdges = [];
+  if (aiProvider) {
+    try {
+      const resolvedEdges = await resolveSemanticHelpers({
+        projectRoot,
+        routes: scanData.routes,
+        aiProvider
+      });
+      inferredSemanticEdges = resolvedEdges.map((r) => r.edge);
+    } catch {
+    }
+  }
+  if (command === "contract" && (args[1] === "suggest" || args[1] === "--suggest")) {
+    const suggestions = suggestSEOContracts(scanData.routes);
+    console.log(`
+\x1B[1m\u{1F4DC} Suggested SEO Contracts for repository\x1B[0m
+`);
+    console.log(JSON.stringify({ contracts: Object.fromEntries(suggestions.map((c) => [c.name, { routes: c.routes, ...c.requirement }])) }, null, 2));
+    return;
+  }
+  if (command === "diff" || command === "audit" && baseRefArg) {
+    const baseRef = baseRefArg || "main";
+    try {
+      const baseAudit = await auditGitRef(projectRoot, baseRef);
+      const policy = {
+        ...scanData.config.qualityGate || {},
+        contracts: scanData.config.contracts
+      };
+      const diff = computeAuditDiff(baseAudit, auditResult, {
+        policy,
+        aiProvider,
+        inferredSemanticEdges
+      });
+      printQualityGateReport(diff, baseRef, "HEAD", { json: isJson, projectRoot });
+      if (!diff.qualityGate.passed) {
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error(`\x1B[31m\u2716 Quality Gate Error: ${err.message}\x1B[0m`);
+      process.exit(1);
+    }
+    return;
+  }
   if (command === "audit") {
+    if (isJson) {
+      console.log(JSON.stringify(auditResult, null, 2));
+      return;
+    }
     printAuditReport(auditResult, projectRoot);
     const hasErrors = auditResult.findings.some((f) => f.severity === "error");
     if (hasErrors && process.env.CI) {
@@ -1961,13 +4458,43 @@ async function runCli(args) {
     }
   } else if (command === "fix") {
     const dryRun = args.includes("--dry-run");
+    let baseFiles;
+    if (baseRefArg) {
+      try {
+        const gitRootRes = spawnSync("git", ["rev-parse", "--show-toplevel"], { cwd: projectRoot, encoding: "utf8" });
+        const gitRoot = gitRootRes.status === 0 ? gitRootRes.stdout.trim() : projectRoot;
+        const relToGitRoot = path8.relative(gitRoot, projectRoot).replace(/\\/g, "/");
+        const archiveRef = relToGitRoot && relToGitRoot !== "." ? `${baseRefArg}:${relToGitRoot}` : baseRefArg;
+        const gitArchive = spawnSync("git", ["archive", archiveRef], { cwd: gitRoot, maxBuffer: 64 * 1024 * 1024 });
+        if (gitArchive.status === 0 && gitArchive.stdout) {
+          const tmpDir = fs6.mkdtempSync(path8.join(os.tmpdir(), "crawlemon-base-fix-"));
+          spawnSync("tar", ["-x", "-C", tmpDir], { input: gitArchive.stdout });
+          baseFiles = /* @__PURE__ */ new Map();
+          const walk2 = (d) => {
+            for (const ent of fs6.readdirSync(d, { withFileTypes: true })) {
+              const full = path8.join(d, ent.name);
+              if (ent.isDirectory()) walk2(full);
+              else if (ent.isFile()) {
+                const rel = path8.relative(tmpDir, full).replace(/\\/g, "/");
+                baseFiles.set(rel, fs6.readFileSync(full, "utf8"));
+              }
+            }
+          };
+          walk2(tmpDir);
+          fs6.rmSync(tmpDir, { recursive: true, force: true });
+        }
+      } catch {
+      }
+    }
     const fixResult = await applySafeFixes({
       projectRoot,
       routes: scanData.routes,
       findings: auditResult.findings,
       config: scanData.config,
       dryRun,
-      isAppRouter: scanData.isAppRouter
+      isAppRouter: scanData.isAppRouter,
+      framework: scanData.framework,
+      baseFiles
     });
     printFixReport(fixResult);
   } else if (command === "links") {
@@ -1977,10 +4504,11 @@ async function runCli(args) {
   } else {
     console.log(`
 Unknown command: "${command}"`);
-    console.log("Available commands: audit, fix [--dry-run], links, opportunities\n");
+    console.log("Available commands: diff, audit, fix [--dry-run], links, opportunities\n");
     process.exit(1);
   }
 }
 export {
+  auditGitRef,
   runCli
 };