@decantr/verifier 3.6.0 → 3.7.0

package/dist/index.js

@@ -1,8 +1,8 @@
 // src/index.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync6, readdirSync as readdirSync5, readFileSync as readFileSync6, realpathSync as realpathSync2, statSync as statSync5 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync6, readFileSync as readFileSync7, realpathSync as realpathSync2, statSync as statSync6 } from "fs";
 import { readFile } from "fs/promises";
-import { basename as basename2, dirname as dirname2, extname as extname6, isAbsolute as isAbsolute4, join as join6, relative as relative6, resolve as resolve3 } from "path";
+import { basename as basename2, dirname as dirname3, extname as extname7, isAbsolute as isAbsolute4, join as join7, relative as relative7, resolve as resolve4 } from "path";
 import { evaluateGuard, isV4, validateEssence } from "@decantr/essence-spec";
 import * as ts6 from "typescript";
 
@@ -1008,6 +1008,49 @@ function isNextProject(projectRoot) {
     return false;
   }
 }
+function readProjectDependencies(projectRoot) {
+  try {
+    const pkg = JSON.parse(readFileSync2(join(projectRoot, "package.json"), "utf-8"));
+    return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  } catch {
+    return {};
+  }
+}
+function isFrameworkRuntimeProject(projectRoot, runtimeTarget) {
+  const normalizedTarget = runtimeTarget?.toLowerCase() ?? "";
+  if (["angular", "next", "nextjs", "nuxt", "react", "solid", "svelte", "sveltekit", "vue"].includes(
+    normalizedTarget
+  )) {
+    return true;
+  }
+  if (existsSync(join(projectRoot, "vite.config.js")) || existsSync(join(projectRoot, "vite.config.ts")) || existsSync(join(projectRoot, "angular.json")) || existsSync(join(projectRoot, "svelte.config.js")) || existsSync(join(projectRoot, "svelte.config.ts"))) {
+    return true;
+  }
+  const dependencies = readProjectDependencies(projectRoot);
+  return [
+    "@angular/core",
+    "@angular/router",
+    "@sveltejs/kit",
+    "next",
+    "nuxt",
+    "react",
+    "react-dom",
+    "solid-js",
+    "svelte",
+    "vue"
+  ].some((name) => Boolean(dependencies[name]));
+}
+function hasFrameworkMountPoint(html) {
+  return /\bid=(["'])(?:root|app|__next)\1/i.test(html) || /<app-root(?:\s|>)/i.test(html) || /<[^>]+\bdata-(?:reactroot|sveltekit|astro-cid)\b/i.test(html);
+}
+function hasSemanticStaticAppRoot(html) {
+  return /<main(?:\s|>)/i.test(html) || /<[^>]+\brole=(["'])main\1/i.test(html) || /<section\b[^>]*(?:\bid=(["'])todoapp\1|\bclass=(["'])[^"']*\btodoapp\b[^"']*\2)/i.test(html);
+}
+function rootDocumentLooksUsable(html, options) {
+  if (options.frameworkDocumentOutput) return true;
+  if (hasFrameworkMountPoint(html)) return true;
+  return !options.frameworkRuntimeProject && hasSemanticStaticAppRoot(html);
+}
 async function startStaticServer(rootDir) {
   const server = createServer((req, res) => {
     const requestedUrl = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -1070,6 +1113,7 @@ async function auditBuiltDist(projectRoot, options = {}) {
   }
   const routeHints = Array.isArray(options.routeHints) && options.routeHints.length > 0 ? options.routeHints.map((route) => normalizeRouteHint(route)).filter(Boolean).slice(0, 8) : ["/"];
   const frameworkDocumentOutput = isNextProject(projectRoot);
+  const frameworkRuntimeProject = isFrameworkRuntimeProject(projectRoot, options.runtimeTarget);
   const indexHtml = readFileSync2(indexPath, "utf-8");
   const assetPaths = extractAssetPaths(indexHtml);
   const server = await startStaticServer(distDir);
@@ -1077,7 +1121,7 @@ async function auditBuiltDist(projectRoot, options = {}) {
     const rootResponse = await fetch(`${server.baseUrl}/`);
     const rootHtml = await rootResponse.text();
     const failures = frameworkDocumentOutput ? ["next-build-output"] : [];
-    const rootDocumentOk = rootResponse.ok && (frameworkDocumentOutput || /id="root"/.test(rootHtml));
+    const rootDocumentOk = rootResponse.ok && rootDocumentLooksUsable(rootHtml, { frameworkDocumentOutput, frameworkRuntimeProject });
     const titleOk = /<title>[^<]+<\/title>/i.test(rootHtml);
     const langOk = /<html[^>]*\slang=(["'])[^"']+\1/i.test(rootHtml);
     const viewportOk = /<meta[^>]+name=(["'])viewport\1[^>]*>/i.test(rootHtml);
@@ -1157,7 +1201,7 @@ async function auditBuiltDist(projectRoot, options = {}) {
     for (const routeHint of routeHints) {
       const routeResponse = await fetch(`${server.baseUrl}${routeHint}`);
       const routeHtml = await routeResponse.text();
-      const routeRootDocumentOk = routeResponse.ok && (frameworkDocumentOutput || /id="root"/.test(routeHtml));
+      const routeRootDocumentOk = routeResponse.ok && rootDocumentLooksUsable(routeHtml, { frameworkDocumentOutput, frameworkRuntimeProject });
       const routeTitleOk = /<title>[^<]+<\/title>/i.test(routeHtml);
       const routeLangOk = /<html[^>]*\slang=(["'])[^"']+\1/i.test(routeHtml);
       const routeViewportOk = /<meta[^>]+name=(["'])viewport\1[^>]*>/i.test(routeHtml);
@@ -1965,147 +2009,908 @@ function deriveVerificationDiagnostic(input) {
   };
 }
 
-// src/graph-anchors.ts
-function payloadRecord(payload) {
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-}
-function payloadString(payload, key) {
-  const value = payloadRecord(payload)[key];
-  return typeof value === "string" ? value : void 0;
-}
-function slug(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9_.:/-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function normalizedHaystack(finding) {
-  return [
-    finding.id,
-    finding.category,
-    finding.message,
-    finding.target,
-    finding.file,
-    finding.rule,
-    ...finding.evidence ?? []
-  ].filter((entry) => typeof entry === "string" && entry.length > 0).join("\n").toLowerCase();
+// src/discovery.ts
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { dirname, extname as extname3, join as join3, relative as relative3, resolve } from "path";
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte"
+]);
+var STYLE_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
+var PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte", ".html"]);
+var MAX_FILE_READ_BYTES = 512 * 1024;
+var MAX_WALK_FILES = 8e3;
+var MAX_REPORT_ROUTES = 120;
+var MAX_COMPONENT_ITEMS = 160;
+var ROUTE_ASSET_EXTENSION_RE = /\.(?:avif|bmp|css|gif|ico|jpeg|jpg|js|json|map|mp4|pdf|png|svg|webp|woff2?)$/i;
+var ROUTE_VARIABLE_NAMES = "(?:path|pathname|route|currentPath|currentRoute|locationPath|activePath)";
+var JSX_ROUTE_PATH_RE = /<(?:Route|[A-Z][\w.]*Route)\b[^>]*\bpath\s*=\s*(?:"([^"]+)"|'([^']+)'|{\s*"([^"]+)"\s*}|{\s*'([^']+)'\s*}|{\s*`([^`]+)`\s*})/g;
+var OBJECT_ROUTE_PATH_RE = /\bpath\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/g;
+var TANSTACK_FILE_ROUTE_RE = /\bcreate(?:Lazy)?FileRoute\s*\(\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/g;
+var STATIC_HTML_ENTRY_FILES = [
+  "index.html",
+  "docs/index.html",
+  "src/index.html",
+  "public/index.html",
+  "dist/index.html"
+];
+var STATIC_HTML_ROUTE_DIRS = ["demos", "examples"];
+var RULE_FILES = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  "GEMINI.md",
+  ".cursorrules",
+  ".cursor/rules",
+  ".claude/rules",
+  ".github/copilot-instructions.md",
+  "copilot-instructions.md",
+  ".windsurfrules"
+];
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "coverage",
+  "dist",
+  "build",
+  "node_modules",
+  "out",
+  "target",
+  "vendor"
+]);
+var EXCLUDED_COMPONENT_FILE_RE = /(?:^|\/)(?:__tests__|tests?|mocks?|fixtures?|generated|__generated__)(?:\/|$)|(?:\.test|\.spec|\.stories|\.story|\.mock|\.fixture|\.gen|\.d)\.[cm]?[tj]sx?$/i;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function graphAnchor(snapshot, node, confidence, reason, route) {
-  const anchor = {
-    snapshot_id: snapshot.id,
-    source_hash: snapshot.source_hash,
-    node_id: node.id,
-    node_type: node.type,
-    confidence,
-    reason
-  };
-  if (route) anchor.route = route;
-  return anchor;
+function readTextFile(path, maxBytes = MAX_FILE_READ_BYTES) {
+  try {
+    const stat = statSync2(path);
+    if (!stat.isFile() || stat.size > maxBytes) return null;
+    return readFileSync4(path, "utf-8");
+  } catch {
+    return null;
+  }
 }
-function routeForNode(snapshot, nodeId, visited = /* @__PURE__ */ new Set()) {
-  if (visited.has(nodeId)) return void 0;
-  visited.add(nodeId);
-  if (nodeId.startsWith("rt:")) {
-    const route2 = snapshot.nodes.find((node) => node.id === nodeId);
-    return payloadString(route2?.payload, "path") ?? nodeId.replace(/^rt:/, "");
+function readPackageJson(dir) {
+  const path = join3(dir, "package.json");
+  if (!existsSync3(path)) return { value: null, present: false, valid: false };
+  const content = readTextFile(path);
+  if (!content) return { value: null, present: true, valid: false };
+  try {
+    const parsed = JSON.parse(content);
+    return {
+      value: isRecord(parsed) ? parsed : null,
+      present: true,
+      valid: isRecord(parsed)
+    };
+  } catch {
+    return { value: null, present: true, valid: false };
   }
-  const sourceNode = snapshot.nodes.find(
-    (node) => node.id === nodeId && node.type === "SourceArtifact"
-  );
-  if (sourceNode) {
-    const sourceEdges = snapshot.edges.filter(
-      (edge) => edge.relation === "NODE_DERIVED_FROM_SOURCE" && edge.dst === nodeId
-    );
-    const sortedSourceEdges = [
-      ...sourceEdges.filter((edge) => edge.src.startsWith("rt:")),
-      ...sourceEdges.filter((edge) => !edge.src.startsWith("rt:"))
-    ];
-    for (const edge of sortedSourceEdges) {
-      const route2 = routeForNode(snapshot, edge.src, visited);
-      if (route2) return route2;
-    }
-    return void 0;
+}
+function hasWorkspaceMarker(dir) {
+  if (existsSync3(join3(dir, "pnpm-workspace.yaml")) || existsSync3(join3(dir, "turbo.json")) || existsSync3(join3(dir, "nx.json"))) {
+    return true;
   }
-  const pageId = snapshot.nodes.find((node) => node.id === nodeId && node.type === "Page")?.id ?? snapshot.edges.find((edge) => edge.relation === "PAGE_COMPOSES_PATTERN" && edge.dst === nodeId)?.src ?? snapshot.edges.find((edge) => edge.relation === "PAGE_USES_SHELL" && edge.dst === nodeId)?.src;
-  if (!pageId) return void 0;
-  const routeEdge = snapshot.edges.find(
-    (edge) => edge.relation === "PAGE_ROUTED_AT_ROUTE" && edge.src === pageId
-  );
-  if (!routeEdge) return void 0;
-  const route = snapshot.nodes.find((node) => node.id === routeEdge.dst);
-  return payloadString(route?.payload, "path") ?? routeEdge.dst.replace(/^rt:/, "");
+  return Boolean(readPackageJson(dir).value?.workspaces);
 }
-function findProjectNode(snapshot) {
-  return snapshot.nodes.find((node) => node.id === snapshot.project_id) ?? snapshot.nodes.find((node) => node.type === "Project");
+function findWorkspaceRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (hasWorkspaceMarker(current)) return current;
+    const parent = dirname(current);
+    if (parent === current) return resolve(startDir);
+    current = parent;
+  }
 }
-function findLocalRuleNode(snapshot, finding) {
-  const candidates = [finding.rule, finding.target, finding.id].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
-  if (candidates.length === 0) return null;
-  return snapshot.nodes.find((node) => {
-    if (node.type !== "LocalRule") return false;
-    const payloadId = payloadString(node.payload, "id");
-    const ids = [node.id.replace(/^rule:/, ""), payloadId ? slug(payloadId) : null].filter(
-      (entry) => Boolean(entry)
-    );
-    return ids.some((id) => candidates.some((candidate) => id === candidate));
-  }) ?? null;
+function packageManagerFromName(value) {
+  const name = value?.split("@")[0];
+  if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun") return name;
+  return "unknown";
 }
-function findStyleBridgeNode(snapshot, finding) {
-  const haystack = normalizedHaystack(finding);
-  const candidates = [finding.rule, finding.target, finding.id, ...finding.evidence ?? []].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
-  const styleBridgeNodes = snapshot.nodes.filter((node) => node.type === "StyleBridge");
-  if (styleBridgeNodes.length === 0) return null;
-  return styleBridgeNodes.find((node) => {
-    const payloadId = payloadString(node.payload, "id");
-    const payloadLabel = payloadString(node.payload, "label");
-    const ids = [
-      node.id.replace(/^bridge:/, ""),
-      payloadId ? slug(payloadId) : null,
-      payloadLabel ? slug(payloadLabel) : null
-    ].filter((entry) => Boolean(entry));
-    return ids.some(
-      (id) => candidates.some((candidate) => id === candidate || candidate.includes(id)) || haystack.includes(id.toLowerCase())
-    );
-  }) ?? (haystack.includes("style-bridge") || haystack.includes("style bridge") ? styleBridgeNodes[0] ?? null : null);
+function detectPackageManager(appRoot, workspaceRoot) {
+  let current = resolve(appRoot);
+  const stop = resolve(workspaceRoot);
+  while (true) {
+    const declared = packageManagerFromName(readPackageJson(current).value?.packageManager);
+    if (declared !== "unknown") return declared;
+    if (existsSync3(join3(current, "pnpm-lock.yaml"))) return "pnpm";
+    if (existsSync3(join3(current, "yarn.lock"))) return "yarn";
+    if (existsSync3(join3(current, "bun.lockb")) || existsSync3(join3(current, "bun.lock")))
+      return "bun";
+    if (existsSync3(join3(current, "package-lock.json"))) return "npm";
+    const parent = dirname(current);
+    if (parent === current || current === stop) return "unknown";
+    current = parent;
+  }
 }
-function findRouteNode(snapshot, finding) {
-  const haystack = normalizedHaystack(finding);
-  const exactTarget = finding.target?.startsWith("/") ? finding.target : null;
-  const routes = snapshot.nodes.filter((node) => node.type === "Route").map((node) => ({
-    node,
-    path: payloadString(node.payload, "path") ?? node.id.replace(/^rt:/, "")
-  })).sort((a, b) => b.path.length - a.path.length);
-  return routes.find((route) => route.path === exactTarget)?.node ?? routes.find((route) => route.path !== "/" && haystack.includes(route.path.toLowerCase()))?.node ?? null;
+function hasAnyFile(projectRoot, paths) {
+  return paths.some((path) => existsSync3(join3(projectRoot, path)));
 }
-function findPageNode(snapshot, finding) {
-  const candidates = [finding.target, finding.id].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
-  if (candidates.length === 0) return null;
-  return snapshot.nodes.find((node) => {
-    if (node.type !== "Page") return false;
-    const payloadId = payloadString(node.payload, "id");
-    const payloadSection = payloadString(node.payload, "section");
-    const ids = [
-      node.id.replace(/^pg:/, ""),
-      payloadId ? slug(payloadId) : null,
-      payloadId && payloadSection ? slug(`${payloadSection}:${payloadId}`) : null
-    ].filter((entry) => Boolean(entry));
-    return ids.some((id) => candidates.some((candidate) => id === candidate));
-  }) ?? null;
+function hasStaticHtmlSurface(projectRoot) {
+  if (hasAnyFile(projectRoot, STATIC_HTML_ENTRY_FILES)) return true;
+  return STATIC_HTML_ROUTE_DIRS.some((dir) => existsSync3(join3(projectRoot, dir, "index.html")));
 }
-function findPatternNode(snapshot, finding) {
-  const haystack = normalizedHaystack(finding);
-  return snapshot.nodes.find((node) => {
-    if (node.type !== "Pattern") return false;
-    const payloadId = payloadString(node.payload, "id");
-    return [node.id.replace(/^pat:/, ""), payloadId].filter((entry) => Boolean(entry)).some((id) => haystack.includes(id.toLowerCase()));
-  }) ?? null;
+function shouldSkipDir(name) {
+  return SKIP_DIRS.has(name) || name.startsWith(".") && name !== ".github";
 }
-function findSourceArtifactNode(snapshot, finding) {
-  const haystack = normalizedHaystack(finding);
-  return snapshot.nodes.find((node) => {
-    if (node.type !== "SourceArtifact") return false;
-    const path = payloadString(node.payload, "path");
-    return path ? haystack.includes(path.toLowerCase()) : false;
-  }) ?? null;
+function walkFiles(projectRoot, options = {}) {
+  const files = [];
+  function walk(dir) {
+    if (files.length >= MAX_WALK_FILES) return;
+    let entries;
+    try {
+      entries = readdirSync3(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= MAX_WALK_FILES) return;
+      const fullPath = join3(dir, entry);
+      let stat;
+      try {
+        stat = statSync2(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (shouldSkipDir(entry) && !options.includeHidden) continue;
+        walk(fullPath);
+        continue;
+      }
+      if (!stat.isFile()) continue;
+      const rel = relative3(projectRoot, fullPath).replace(/\\/g, "/");
+      const ext = extname3(entry).toLowerCase();
+      if (!options.extensions || options.extensions.has(ext)) files.push(rel);
+    }
+  }
+  walk(projectRoot);
+  return files;
 }
-function normalizePath3(value) {
+function dependencyVersion(dependencies, names) {
+  for (const name of names) {
+    const version = dependencies[name];
+    if (version) return version.replace(/^[~^]/, "");
+  }
+  return null;
+}
+function detectPrimaryLanguage(projectRoot, packageJsonPresent) {
+  const sourceFiles = walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS });
+  if (hasAnyFile(projectRoot, ["tsconfig.json"]) || sourceFiles.some((file) => /\.(tsx|ts)$/.test(file))) {
+    return "typescript";
+  }
+  if (sourceFiles.some((file) => /\.(jsx|js|mjs|cjs)$/.test(file))) return "javascript";
+  if (packageJsonPresent) return hasStaticHtmlSurface(projectRoot) ? "html" : "javascript";
+  if (hasAnyFile(projectRoot, ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"]))
+    return "python";
+  if (hasAnyFile(projectRoot, ["go.mod"])) return "go";
+  if (hasAnyFile(projectRoot, ["Cargo.toml"])) return "rust";
+  if (hasStaticHtmlSurface(projectRoot)) return "html";
+  return "unknown";
+}
+function detectProjectIdentity(projectRoot, workspaceRoot) {
+  const packageRead = readPackageJson(projectRoot);
+  const pkg = packageRead.value;
+  const dependencies = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  const evidence = [];
+  let framework = "unknown";
+  let frameworkVersion = null;
+  if (hasAnyFile(projectRoot, ["next.config.js", "next.config.ts", "next.config.mjs"]) || dependencies.next) {
+    framework = "nextjs";
+    frameworkVersion = dependencyVersion(dependencies, ["next"]);
+    evidence.push("Next.js config or dependency");
+  } else if (hasAnyFile(projectRoot, ["nuxt.config.js", "nuxt.config.ts"]) || dependencies.nuxt) {
+    framework = "nuxt";
+    frameworkVersion = dependencyVersion(dependencies, ["nuxt"]);
+    evidence.push("Nuxt config or dependency");
+  } else if (hasAnyFile(projectRoot, ["astro.config.mjs", "astro.config.ts"]) || dependencies.astro) {
+    framework = "astro";
+    frameworkVersion = dependencyVersion(dependencies, ["astro"]);
+    evidence.push("Astro config or dependency");
+  } else if (hasAnyFile(projectRoot, ["svelte.config.js", "svelte.config.ts"]) || dependencies.svelte || dependencies["@sveltejs/kit"]) {
+    framework = "svelte";
+    frameworkVersion = dependencyVersion(dependencies, ["svelte", "@sveltejs/kit"]);
+    evidence.push("Svelte/SvelteKit config or dependency");
+  } else if (hasAnyFile(projectRoot, ["angular.json"]) || dependencies["@angular/core"]) {
+    framework = "angular";
+    frameworkVersion = dependencyVersion(dependencies, ["@angular/core"]);
+    evidence.push("Angular config or dependency");
+  } else if (dependencies["solid-js"]) {
+    framework = "solid";
+    frameworkVersion = dependencyVersion(dependencies, ["solid-js"]);
+    evidence.push("Solid dependency");
+  } else if (dependencies.vue) {
+    framework = "vue";
+    frameworkVersion = dependencyVersion(dependencies, ["vue"]);
+    evidence.push("Vue dependency");
+  } else if (dependencies.react || dependencies["react-dom"] || hasAnyFile(projectRoot, ["vite.config.ts", "vite.config.js"])) {
+    framework = dependencies.react || dependencies["react-dom"] ? "react" : "unknown";
+    frameworkVersion = dependencyVersion(dependencies, ["react", "react-dom"]);
+    if (framework === "react") evidence.push("React dependency");
+  }
+  if (framework === "unknown" && hasStaticHtmlSurface(projectRoot)) {
+    framework = "html";
+    evidence.push("static HTML entrypoint");
+  }
+  const cssFiles = walkFiles(projectRoot, { extensions: STYLE_EXTENSIONS });
+  const hasTailwind = hasAnyFile(projectRoot, [
+    "tailwind.config.js",
+    "tailwind.config.ts",
+    "tailwind.config.mjs",
+    "tailwind.config.cjs"
+  ]) || Boolean(dependencies.tailwindcss) || cssFiles.some((file) => readTextFile(join3(projectRoot, file), 128 * 1024)?.includes("@theme"));
+  return {
+    framework,
+    frameworkVersion,
+    packageManager: detectPackageManager(projectRoot, workspaceRoot),
+    primaryLanguage: detectPrimaryLanguage(projectRoot, packageRead.present),
+    hasTypeScript: hasAnyFile(projectRoot, ["tsconfig.json"]) || walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS }).some(
+      (file) => /\.(tsx|ts)$/.test(file)
+    ),
+    hasTailwind,
+    hasDecantr: existsSync3(join3(projectRoot, "decantr.essence.json")) || existsSync3(join3(projectRoot, ".decantr")) || Boolean(dependencies["@decantr/cli"] || dependencies["@decantr/css"]),
+    packageName: typeof pkg?.name === "string" ? pkg.name : null,
+    packageJsonPresent: packageRead.present,
+    packageJsonValid: packageRead.valid,
+    dependencies,
+    evidence
+  };
+}
+function segmentToRoute(segment) {
+  if (segment.startsWith("(") && segment.endsWith(")")) return null;
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    const param = segment.slice(1, -1);
+    if (param.startsWith("...")) return `:${param.slice(3)}*`;
+    if (param.startsWith("[...") && param.endsWith("]")) return `:${param.slice(4, -1)}*`;
+    return `:${param}`;
+  }
+  return segment;
+}
+function normalizeRouteLiteral(value) {
+  const withoutHash = value.trim().split("#")[0];
+  const cleaned = withoutHash.includes("?") && !withoutHash.endsWith(")?") ? withoutHash.split("?")[0] : withoutHash;
+  if (!cleaned || cleaned === "/") return ["/"];
+  if (cleaned === "*" || cleaned === "**" || cleaned.startsWith("#")) return [];
+  if (cleaned === "/*" || cleaned === "/**") return [];
+  if (ROUTE_ASSET_EXTENSION_RE.test(cleaned)) return [];
+  const optionalGroup = cleaned.match(/^\/\(([^()]+)\)\?$/);
+  if (optionalGroup) {
+    return [
+      "/",
+      ...optionalGroup[1].split("|").map((segment) => segment.trim()).filter(Boolean).map((segment) => `/${segment}`)
+    ];
+  }
+  const withoutTrailingWildcard = cleaned.endsWith("*") && !cleaned.endsWith("/*") && !/:\w+\*$/.test(cleaned) ? cleaned.slice(0, -1) : cleaned;
+  const normalized = withoutTrailingWildcard.replace(/\/+$/g, "") || "/";
+  if (normalized === "/*" || normalized === "/**") return [];
+  return [normalized.startsWith("/") ? normalized : `/${normalized}`];
+}
+function addRouteSignal(signals, input) {
+  if (input.path === null || input.path === void 0) return;
+  for (const path of normalizeRouteLiteral(input.path)) {
+    signals.push({ ...input, path });
+  }
+}
+function fileRouteFromPath(file, baseDir) {
+  let withoutExt = file.slice(0, -extname3(file).length);
+  if (withoutExt.endsWith("/index")) withoutExt = withoutExt.slice(0, -"/index".length);
+  withoutExt = withoutExt.replace(/\/(?:page|\+page)$/u, "");
+  withoutExt = withoutExt.replace(
+    new RegExp(`^${baseDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`),
+    ""
+  );
+  const parts = withoutExt.split("/").filter(Boolean).map((part) => segmentToRoute(part)).filter(Boolean);
+  return `/${parts.join("/")}` || "/";
+}
+function scanFileRoutes(projectRoot, baseDir, extensions = PAGE_EXTENSIONS, routeFileNames) {
+  const fullBase = join3(projectRoot, baseDir);
+  if (!existsSync3(fullBase)) return [];
+  return walkFiles(fullBase, { extensions }).flatMap((file) => {
+    const baseName = file.split("/").pop() ?? file;
+    const routeFileName = baseName.slice(0, -extname3(baseName).length);
+    if (routeFileNames && !routeFileNames.has(routeFileName)) return [];
+    if (routeFileName.startsWith("_")) return [];
+    const rel = relative3(projectRoot, join3(fullBase, file)).replace(/\\/g, "/");
+    return [
+      {
+        path: fileRouteFromPath(rel, baseDir),
+        file: rel,
+        kind: "file-route",
+        confidence: "high",
+        taskable: true,
+        evidence: `file route ${rel}`
+      }
+    ];
+  });
+}
+function collectRouteLiterals(pattern, content, file, signals, kind) {
+  for (const match of content.matchAll(pattern)) {
+    const value = match.slice(1).find((item) => typeof item === "string");
+    addRouteSignal(signals, {
+      path: value,
+      file,
+      kind,
+      confidence: kind === "pathname-branch" ? "medium" : "high",
+      taskable: true,
+      evidence: `${kind} route literal`
+    });
+  }
+}
+function collectPathnameBranchRoutes(content, file, signals) {
+  const beforeCount = signals.length;
+  collectRouteLiterals(
+    new RegExp(
+      `\\b${ROUTE_VARIABLE_NAMES}\\b\\s*(?:===|!==|==|!=)\\s*["'\`](\\/[^"'\`]+)["'\`]`,
+      "g"
+    ),
+    content,
+    file,
+    signals,
+    "pathname-branch"
+  );
+  collectRouteLiterals(
+    new RegExp(
+      `["'\`](\\/[^"'\`]+)["'\`]\\s*(?:===|!==|==|!=)\\s*\\b${ROUTE_VARIABLE_NAMES}\\b`,
+      "g"
+    ),
+    content,
+    file,
+    signals,
+    "pathname-branch"
+  );
+  collectRouteLiterals(
+    /\bcase\s+["'`](\/[^"'`]+)["'`]\s*:/g,
+    content,
+    file,
+    signals,
+    "pathname-branch"
+  );
+  const hasPathnameSignal = /\b(?:window\.|document\.)?location\.pathname\b|\bpathname\b/.test(
+    content
+  );
+  if (signals.length > beforeCount || hasPathnameSignal) {
+    collectRouteLiterals(
+      /\b(?:href|to)\s*=\s*(?:"([^"]+)"|'([^']+)'|{\s*"([^"]+)"\s*}|{\s*'([^']+)'\s*}|{\s*`([^`]+)`\s*})/g,
+      content,
+      file,
+      signals,
+      "pathname-branch"
+    );
+  }
+}
+function detectSourceRouteSignals(projectRoot, identity) {
+  const signals = [];
+  const files = walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS });
+  const hasTanstack = Boolean(
+    identity.dependencies["@tanstack/react-router"] || identity.dependencies["@tanstack/router-core"]
+  );
+  for (const file of files) {
+    const content = readTextFile(join3(projectRoot, file));
+    if (!content) continue;
+    const isTanstackFile = content.includes("@tanstack/react-router") || content.includes("createFileRoute") || content.includes("createLazyFileRoute") || content.includes("createRoute") || hasTanstack && (/\brouteTree\b/.test(content) || /routeTree\.gen\.[cm]?[tj]sx?$/.test(file));
+    const isReactRouterFile = content.includes("react-router-dom") || content.includes("react-router") || content.includes("<Routes") || content.includes("createBrowserRouter") || content.includes("createHashRouter") || content.includes("RouterProvider") || content.includes("HashRouter") || content.includes("BrowserRouter");
+    if (isTanstackFile) {
+      collectRouteLiterals(TANSTACK_FILE_ROUTE_RE, content, file, signals, "tanstack-router");
+      collectRouteLiterals(OBJECT_ROUTE_PATH_RE, content, file, signals, "tanstack-router");
+      if (/\bcreateRootRoute(?:WithContext)?\s*\(/.test(content)) {
+        addRouteSignal(signals, {
+          path: "/",
+          file,
+          kind: "tanstack-router",
+          confidence: "high",
+          taskable: true,
+          evidence: "TanStack root route"
+        });
+      }
+    }
+    if (isReactRouterFile) {
+      collectRouteLiterals(JSX_ROUTE_PATH_RE, content, file, signals, "react-router");
+      collectRouteLiterals(OBJECT_ROUTE_PATH_RE, content, file, signals, "react-router");
+    }
+    collectPathnameBranchRoutes(content, file, signals);
+    const hasRouteSpecSignal = content.includes("@wasp.sh/spec") || /\b(?:const|export\s+const)\s+\w*Spec\b/.test(content) || /\bapp\s*\(\s*\{[\s\S]*\bspec\s*:/.test(content);
+    if (hasRouteSpecSignal) {
+      collectRouteLiterals(
+        /\broute\s*\(\s*["'`][^"'`]*["'`]\s*,\s*["'`](\/[^"'`]*)["'`]\s*,\s*page\s*\(/g,
+        content,
+        file,
+        signals,
+        "source-declared"
+      );
+    }
+  }
+  return signals;
+}
+function htmlRouteFromFile(file) {
+  let withoutExt = file.slice(0, -extname3(file).length).replace(/\\/g, "/");
+  if (withoutExt.endsWith("/index")) withoutExt = withoutExt.slice(0, -"/index".length);
+  if (withoutExt === "index" || withoutExt === "docs" || withoutExt === "src" || withoutExt === "public" || withoutExt === "dist") {
+    return "/";
+  }
+  return `/${withoutExt.split("/").filter(Boolean).join("/")}` || "/";
+}
+function scanStaticHtmlRouteSignals(projectRoot) {
+  const signals = [];
+  for (const file of STATIC_HTML_ENTRY_FILES) {
+    if (!existsSync3(join3(projectRoot, file))) continue;
+    signals.push({
+      path: "/",
+      file,
+      kind: "html-route",
+      confidence: "high",
+      taskable: true,
+      evidence: "static HTML entrypoint"
+    });
+    break;
+  }
+  for (const dir of STATIC_HTML_ROUTE_DIRS) {
+    const fullDir = join3(projectRoot, dir);
+    if (!existsSync3(fullDir)) continue;
+    for (const file of walkFiles(fullDir, { extensions: /* @__PURE__ */ new Set([".html", ".htm"]) })) {
+      const rel = relative3(projectRoot, join3(fullDir, file)).replace(/\\/g, "/");
+      signals.push({
+        path: htmlRouteFromFile(rel),
+        file: rel,
+        kind: "html-route",
+        confidence: "medium",
+        taskable: true,
+        evidence: "nested static HTML route"
+      });
+    }
+  }
+  return signals;
+}
+function discoverRoutes(projectRoot, identity) {
+  const fileRouteSignals = [];
+  const nextAppSignals = ["src/app", "app"].flatMap(
+    (dir) => scanFileRoutes(projectRoot, dir, PAGE_EXTENSIONS, /* @__PURE__ */ new Set(["page"]))
+  );
+  const pagesSignals = ["src/pages", "pages"].flatMap((dir) => scanFileRoutes(projectRoot, dir));
+  if (identity.framework === "nextjs") {
+    fileRouteSignals.push(...nextAppSignals, ...pagesSignals);
+  } else if (identity.framework === "svelte") {
+    fileRouteSignals.push(
+      ...scanFileRoutes(
+        projectRoot,
+        "src/routes",
+        /* @__PURE__ */ new Set([".svelte", ".ts", ".js"]),
+        /* @__PURE__ */ new Set(["+page"])
+      )
+    );
+  } else if (identity.framework === "nuxt") {
+    fileRouteSignals.push(...scanFileRoutes(projectRoot, "pages", /* @__PURE__ */ new Set([".vue"])));
+    fileRouteSignals.push(...scanFileRoutes(projectRoot, "app/pages", /* @__PURE__ */ new Set([".vue"])));
+  } else if (identity.framework !== "react") {
+    fileRouteSignals.push(...pagesSignals);
+  }
+  const sourceSignals = detectSourceRouteSignals(projectRoot, identity);
+  const angularSignals = [];
+  if (identity.framework === "angular") {
+    for (const file of walkFiles(projectRoot, { extensions: /* @__PURE__ */ new Set([".ts", ".js"]) })) {
+      const content = readTextFile(join3(projectRoot, file));
+      if (!content || !/@angular\/router|RouterModule\.forRoot|provideRouter|\bRoutes\s*=/.test(content))
+        continue;
+      collectRouteLiterals(
+        /\bpath\s*:\s*["'`]([^"'`]*)["'`]/g,
+        content,
+        file,
+        angularSignals,
+        "angular-router"
+      );
+    }
+  }
+  const htmlSignals = scanStaticHtmlRouteSignals(projectRoot);
+  let selectedSignals = [];
+  let strategy = "none";
+  if (identity.framework === "nextjs" && nextAppSignals.length > 0 && pagesSignals.length > 0) {
+    selectedSignals = [...nextAppSignals, ...pagesSignals];
+    strategy = "mixed-next-router";
+  } else if (identity.framework === "nextjs" && nextAppSignals.length > 0) {
+    selectedSignals = nextAppSignals;
+    strategy = "app-router";
+  } else if (identity.framework === "nextjs" && pagesSignals.length > 0) {
+    selectedSignals = pagesSignals;
+    strategy = "pages-router";
+  } else if (identity.framework === "angular" && angularSignals.length > 0) {
+    selectedSignals = angularSignals;
+    strategy = "angular-router";
+  } else if (identity.framework === "svelte" && fileRouteSignals.length > 0) {
+    selectedSignals = fileRouteSignals;
+    strategy = "sveltekit-router";
+  } else if (identity.framework === "nuxt" && fileRouteSignals.length > 0) {
+    selectedSignals = fileRouteSignals;
+    strategy = "nuxt-router";
+  } else if (sourceSignals.some((signal) => signal.kind === "tanstack-router")) {
+    selectedSignals = sourceSignals;
+    strategy = "source-declared";
+  } else if (sourceSignals.length > 0) {
+    selectedSignals = sourceSignals;
+    strategy = identity.framework === "vue" ? "vue-router" : "react-router";
+  } else if (pagesSignals.length > 0) {
+    selectedSignals = pagesSignals;
+    strategy = "pages-router";
+  } else if (htmlSignals.length > 0) {
+    selectedSignals = htmlSignals;
+    strategy = "static-html";
+  }
+  const taskable = /* @__PURE__ */ new Map();
+  for (const signal of selectedSignals) {
+    if (!signal.taskable) continue;
+    if (taskable.has(signal.path)) continue;
+    taskable.set(signal.path, {
+      path: signal.path,
+      file: signal.file,
+      hasLayout: false,
+      confidence: signal.confidence,
+      source: signal.kind
+    });
+  }
+  const routeSignals = selectedSignals.slice(0, MAX_REPORT_ROUTES);
+  const taskableRoutes = [...taskable.values()].slice(0, MAX_REPORT_ROUTES);
+  const confidence = taskableRoutes.length >= 3 ? "high" : taskableRoutes.length > 0 ? "medium" : "low";
+  return {
+    strategy,
+    routeSignals,
+    taskableRoutes,
+    routeSignalCount: selectedSignals.length,
+    taskableRouteCount: taskableRoutes.length,
+    confidence,
+    limitations: taskableRoutes.length === 0 ? ["No taskable route declarations were discovered from static source evidence."] : selectedSignals.length > taskableRoutes.length ? ["Some duplicate or non-taskable route signals were collapsed before task context."] : []
+  };
+}
+function discoverComponents(projectRoot, routes) {
+  const sourceFiles = walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS });
+  const items = /* @__PURE__ */ new Map();
+  const evidence = [];
+  for (const file of sourceFiles) {
+    if (!/\.(tsx|jsx|vue|svelte)$/.test(file) && !/\.(ts|js)$/.test(file)) continue;
+    if (EXCLUDED_COMPONENT_FILE_RE.test(file)) continue;
+    const content = readTextFile(join3(projectRoot, file), 256 * 1024) ?? "";
+    if (!/[<][A-Za-z][^>]*>/.test(content) && !/\.(vue|svelte)$/.test(file)) continue;
+    const base = file.split("/").pop() ?? file;
+    const nameFromFile = base.slice(0, -extname3(base).length);
+    const names = /* @__PURE__ */ new Set();
+    const isRouteLocal = routes.taskableRoutes.some((route) => route.file === file);
+    for (const match of content.matchAll(/\bexport\s+function\s+([A-Z][A-Za-z0-9_]*)\b/g))
+      names.add(match[1] ?? "");
+    for (const match of content.matchAll(
+      /\bexport\s+default\s+function\s+([A-Z][A-Za-z0-9_]*)?\b/g
+    ))
+      names.add(match[1] || nameFromFile);
+    for (const match of content.matchAll(
+      /\bexport\s+const\s+([A-Z][A-Za-z0-9_]*)\s*=\s*(?:memo|forwardRef|\()/g
+    ))
+      names.add(match[1] ?? "");
+    if (isRouteLocal) {
+      for (const match of content.matchAll(/\bfunction\s+([A-Z][A-Za-z0-9_]*)\b/g))
+        names.add(match[1] ?? "");
+      for (const match of content.matchAll(
+        /\bconst\s+([A-Z][A-Za-z0-9_]*)\s*=\s*(?:memo|forwardRef|\()/g
+      ))
+        names.add(match[1] ?? "");
+    }
+    if (/^[A-Z][A-Za-z0-9_-]*$/.test(nameFromFile) && /\.(tsx|jsx|vue|svelte)$/.test(file))
+      names.add(nameFromFile);
+    for (const name of [...names].filter(Boolean)) {
+      const key = `${file}:${name}`;
+      const kind = /export\s+default\s+function/.test(content) && name === nameFromFile ? "default-export" : /\b(?:memo|forwardRef)\b/.test(content) ? "wrapper" : isRouteLocal && !new RegExp(`\\bexport\\s+(?:default\\s+)?(?:function|const)\\s+${name}\\b`).test(
+        content
+      ) ? "route-local" : /^[A-Z]/.test(nameFromFile) && name === nameFromFile ? "pascal-file" : "exported";
+      items.set(key, {
+        name,
+        file,
+        kind,
+        confidence: kind === "pascal-file" ? "medium" : "high"
+      });
+    }
+  }
+  const components = [...items.values()].slice(0, MAX_COMPONENT_ITEMS);
+  const directories = [
+    ...new Set(
+      components.map((component) => component.file.split("/").slice(0, -1).join("/")).filter(Boolean)
+    )
+  ].slice(0, 24);
+  if (directories.some((dir) => !/^src\/(?:components|ui)\b/.test(dir))) {
+    evidence.push("feature-folder and route-local components were included");
+  }
+  if (components.some((component) => component.kind === "wrapper")) {
+    evidence.push("memo/forwardRef wrappers were included");
+  }
+  const confidence = components.length >= 5 && evidence.length > 0 ? "high" : components.length > 0 ? "medium" : "low";
+  return {
+    pageCount: routes.taskableRouteCount,
+    componentCount: components.length,
+    directories,
+    items: components,
+    confidence,
+    evidence,
+    limitations: confidence === "low" ? ["Component inventory is partial because only weak static component signals were found."] : [
+      "Component inventory is static and advisory, not proof that every reusable component was found."
+    ]
+  };
+}
+function extractCssEvidence(content) {
+  const variableMatches = [...content.matchAll(/--[\w-]+\s*:/g)];
+  const colorMatches = [...content.matchAll(/#[0-9a-fA-F]{3,8}\b|rgb[a]?\(|hsl[a]?\(/g)];
+  const themeSignals = /* @__PURE__ */ new Set();
+  if (/\bdark\b|color-scheme:\s*dark|\[data-theme=['"]dark['"]|\.dark\b/.test(content))
+    themeSignals.add("dark mode");
+  if (/@theme\b/.test(content)) themeSignals.add("tailwind v4 @theme");
+  if (/\[data-theme=|data-theme|theme-\w+/.test(content)) themeSignals.add("theme selector");
+  if (/prefers-color-scheme/.test(content)) themeSignals.add("system color preference");
+  return {
+    variables: variableMatches.length,
+    colors: colorMatches.length,
+    dark: themeSignals.has("dark mode") || themeSignals.has("system color preference"),
+    themeSignals: [...themeSignals]
+  };
+}
+function discoverStyling(projectRoot, identity) {
+  const cssFiles = walkFiles(projectRoot, { extensions: STYLE_EXTENSIONS });
+  const themeSignals = /* @__PURE__ */ new Set();
+  let cssVariableCount = 0;
+  let colorTokenCount = 0;
+  let darkMode = false;
+  let configFile = null;
+  let approach = "unknown";
+  const tailwindConfig = [
+    "tailwind.config.js",
+    "tailwind.config.ts",
+    "tailwind.config.mjs",
+    "tailwind.config.cjs"
+  ].find((file) => existsSync3(join3(projectRoot, file)));
+  for (const file of cssFiles.slice(0, 100)) {
+    const content = readTextFile(join3(projectRoot, file), 256 * 1024);
+    if (!content) continue;
+    const evidence = extractCssEvidence(content);
+    cssVariableCount += evidence.variables;
+    colorTokenCount += evidence.colors;
+    darkMode ||= evidence.dark;
+    for (const signal of evidence.themeSignals) themeSignals.add(signal);
+  }
+  if (tailwindConfig || identity.dependencies.tailwindcss || themeSignals.has("tailwind v4 @theme")) {
+    approach = "tailwind";
+    configFile = tailwindConfig ?? (themeSignals.has("tailwind v4 @theme") ? "css @theme" : "package.json");
+  } else if (identity.dependencies["@decantr/css"]) {
+    approach = "decantr-css";
+    configFile = "package.json";
+  } else if (identity.dependencies.bootstrap) {
+    approach = "bootstrap";
+    configFile = "package.json";
+  } else if (identity.dependencies["@mui/material"]) {
+    approach = "mui";
+    configFile = "package.json";
+  } else if (identity.dependencies["@chakra-ui/react"]) {
+    approach = "chakra";
+    configFile = "package.json";
+  } else if (cssFiles.some((file) => file.endsWith(".module.css"))) {
+    approach = "css-modules";
+  } else if (cssFiles.length > 0) {
+    approach = "css";
+  }
+  return {
+    approach,
+    configFile,
+    cssVariableCount,
+    colorTokenCount,
+    darkMode,
+    themeSignals: [...themeSignals]
+  };
+}
+function findAssistantRules(projectRoot) {
+  return RULE_FILES.filter((file) => existsSync3(join3(projectRoot, file)));
+}
+function calculateConfidence(input) {
+  let score = 20;
+  const reasons = [];
+  if (input.project.packageJsonPresent && input.project.packageJsonValid) {
+    score += 15;
+    reasons.push("package.json was readable");
+  }
+  if (input.project.framework !== "unknown") {
+    score += 25;
+    reasons.push(`${input.project.framework} framework signal found`);
+  }
+  if (input.project.primaryLanguage === "typescript") {
+    score += 10;
+    reasons.push("TypeScript source evidence found");
+  }
+  if (input.routes.taskableRouteCount > 0) {
+    score += 20;
+    reasons.push(`${input.routes.taskableRouteCount} taskable route(s) found`);
+  }
+  if (input.components.componentCount > 1) {
+    score += 10;
+    reasons.push(`${input.components.componentCount} component candidate(s) found`);
+  }
+  if (input.styling.approach !== "unknown") {
+    score += 10;
+    reasons.push(`${input.styling.approach} styling signal found`);
+  }
+  const clamped = Math.max(5, Math.min(98, score));
+  return {
+    level: clamped >= 75 ? "high" : clamped >= 45 ? "medium" : "low",
+    score: clamped,
+    reasons: reasons.length > 0 ? reasons : ["Only weak project signals were found."]
+  };
+}
+function discoverProject(projectRoot) {
+  const appRoot = resolve(projectRoot);
+  const workspaceRoot = findWorkspaceRoot(appRoot);
+  const projectPath = relative3(workspaceRoot, appRoot).replace(/\\/g, "/") || ".";
+  const project = detectProjectIdentity(appRoot, workspaceRoot);
+  const routes = discoverRoutes(appRoot, project);
+  const components = discoverComponents(appRoot, routes);
+  const styling = discoverStyling(appRoot, project);
+  const assistant = { ruleFiles: findAssistantRules(appRoot) };
+  const confidence = calculateConfidence({ project, routes, components, styling });
+  const limitations = [...routes.limitations, ...components.limitations];
+  return {
+    schemaVersion: "discovery.v1",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspace: {
+      workspaceRoot,
+      appRoot,
+      projectPath,
+      scope: projectPath === "." ? "single-app" : "workspace-app"
+    },
+    project,
+    routes,
+    components,
+    styling,
+    assistant,
+    confidence,
+    limitations
+  };
+}
+
+// src/graph-anchors.ts
+function payloadRecord(payload) {
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+function payloadString(payload, key) {
+  const value = payloadRecord(payload)[key];
+  return typeof value === "string" ? value : void 0;
+}
+function slug(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_.:/-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function normalizedHaystack(finding) {
+  return [
+    finding.id,
+    finding.category,
+    finding.message,
+    finding.target,
+    finding.file,
+    finding.rule,
+    ...finding.evidence ?? []
+  ].filter((entry) => typeof entry === "string" && entry.length > 0).join("\n").toLowerCase();
+}
+function graphAnchor(snapshot, node, confidence, reason, route) {
+  const anchor = {
+    snapshot_id: snapshot.id,
+    source_hash: snapshot.source_hash,
+    node_id: node.id,
+    node_type: node.type,
+    confidence,
+    reason
+  };
+  if (route) anchor.route = route;
+  return anchor;
+}
+function routeForNode(snapshot, nodeId, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(nodeId)) return void 0;
+  visited.add(nodeId);
+  if (nodeId.startsWith("rt:")) {
+    const route2 = snapshot.nodes.find((node) => node.id === nodeId);
+    return payloadString(route2?.payload, "path") ?? nodeId.replace(/^rt:/, "");
+  }
+  const sourceNode = snapshot.nodes.find(
+    (node) => node.id === nodeId && node.type === "SourceArtifact"
+  );
+  if (sourceNode) {
+    const sourceEdges = snapshot.edges.filter(
+      (edge) => edge.relation === "NODE_DERIVED_FROM_SOURCE" && edge.dst === nodeId
+    );
+    const sortedSourceEdges = [
+      ...sourceEdges.filter((edge) => edge.src.startsWith("rt:")),
+      ...sourceEdges.filter((edge) => !edge.src.startsWith("rt:"))
+    ];
+    for (const edge of sortedSourceEdges) {
+      const route2 = routeForNode(snapshot, edge.src, visited);
+      if (route2) return route2;
+    }
+    return void 0;
+  }
+  const pageId = snapshot.nodes.find((node) => node.id === nodeId && node.type === "Page")?.id ?? snapshot.edges.find((edge) => edge.relation === "PAGE_COMPOSES_PATTERN" && edge.dst === nodeId)?.src ?? snapshot.edges.find((edge) => edge.relation === "PAGE_USES_SHELL" && edge.dst === nodeId)?.src;
+  if (!pageId) return void 0;
+  const routeEdge = snapshot.edges.find(
+    (edge) => edge.relation === "PAGE_ROUTED_AT_ROUTE" && edge.src === pageId
+  );
+  if (!routeEdge) return void 0;
+  const route = snapshot.nodes.find((node) => node.id === routeEdge.dst);
+  return payloadString(route?.payload, "path") ?? routeEdge.dst.replace(/^rt:/, "");
+}
+function findProjectNode(snapshot) {
+  return snapshot.nodes.find((node) => node.id === snapshot.project_id) ?? snapshot.nodes.find((node) => node.type === "Project");
+}
+function findLocalRuleNode(snapshot, finding) {
+  const candidates = [finding.rule, finding.target, finding.id].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
+  if (candidates.length === 0) return null;
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "LocalRule") return false;
+    const payloadId = payloadString(node.payload, "id");
+    const ids = [node.id.replace(/^rule:/, ""), payloadId ? slug(payloadId) : null].filter(
+      (entry) => Boolean(entry)
+    );
+    return ids.some((id) => candidates.some((candidate) => id === candidate));
+  }) ?? null;
+}
+function findStyleBridgeNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  const candidates = [finding.rule, finding.target, finding.id, ...finding.evidence ?? []].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
+  const styleBridgeNodes = snapshot.nodes.filter((node) => node.type === "StyleBridge");
+  if (styleBridgeNodes.length === 0) return null;
+  return styleBridgeNodes.find((node) => {
+    const payloadId = payloadString(node.payload, "id");
+    const payloadLabel = payloadString(node.payload, "label");
+    const ids = [
+      node.id.replace(/^bridge:/, ""),
+      payloadId ? slug(payloadId) : null,
+      payloadLabel ? slug(payloadLabel) : null
+    ].filter((entry) => Boolean(entry));
+    return ids.some(
+      (id) => candidates.some((candidate) => id === candidate || candidate.includes(id)) || haystack.includes(id.toLowerCase())
+    );
+  }) ?? (haystack.includes("style-bridge") || haystack.includes("style bridge") ? styleBridgeNodes[0] ?? null : null);
+}
+function findRouteNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  const exactTarget = finding.target?.startsWith("/") ? finding.target : null;
+  const routes = snapshot.nodes.filter((node) => node.type === "Route").map((node) => ({
+    node,
+    path: payloadString(node.payload, "path") ?? node.id.replace(/^rt:/, "")
+  })).sort((a, b) => b.path.length - a.path.length);
+  return routes.find((route) => route.path === exactTarget)?.node ?? routes.find((route) => route.path !== "/" && haystack.includes(route.path.toLowerCase()))?.node ?? null;
+}
+function findPageNode(snapshot, finding) {
+  const candidates = [finding.target, finding.id].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
+  if (candidates.length === 0) return null;
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "Page") return false;
+    const payloadId = payloadString(node.payload, "id");
+    const payloadSection = payloadString(node.payload, "section");
+    const ids = [
+      node.id.replace(/^pg:/, ""),
+      payloadId ? slug(payloadId) : null,
+      payloadId && payloadSection ? slug(`${payloadSection}:${payloadId}`) : null
+    ].filter((entry) => Boolean(entry));
+    return ids.some((id) => candidates.some((candidate) => id === candidate));
+  }) ?? null;
+}
+function findPatternNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "Pattern") return false;
+    const payloadId = payloadString(node.payload, "id");
+    return [node.id.replace(/^pat:/, ""), payloadId].filter((entry) => Boolean(entry)).some((id) => haystack.includes(id.toLowerCase()));
+  }) ?? null;
+}
+function findSourceArtifactNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "SourceArtifact") return false;
+    const path = payloadString(node.payload, "path");
+    return path ? haystack.includes(path.toLowerCase()) : false;
+  }) ?? null;
+}
+function normalizePath3(value) {
   return value ? value.replace(/\\/g, "/").toLowerCase() : null;
 }
 function findExactSourceArtifactNode(snapshot, finding) {
@@ -2361,11 +3166,13 @@ function listKnownInteractions() {
 }
 
 // src/scan.ts
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { extname as extname3, isAbsolute, join as join3, relative as relative3 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { extname as extname4, isAbsolute, join as join4, relative as relative4 } from "path";
 import { decodeHTML, decodeHTMLAttribute } from "entities";
-var SCAN_REPORT_SCHEMA_URL = "https://decantr.ai/schemas/scan-report.v1.json";
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+var SCAN_REPORT_V1_SCHEMA_URL = "https://decantr.ai/schemas/scan-report.v1.json";
+var SCAN_REPORT_V2_SCHEMA_URL = "https://decantr.ai/schemas/scan-report.v2.json";
+var SCAN_REPORT_SCHEMA_URL = SCAN_REPORT_V2_SCHEMA_URL;
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
   ".js",
@@ -2375,25 +3182,10 @@ var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".vue",
   ".svelte"
 ]);
-var STYLE_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
-var PAGE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte", ".html"]);
-var ROUTE_VARIABLE_NAMES = "(?:path|pathname|route|currentPath|currentRoute|locationPath|activePath)";
-var ROUTE_ASSET_EXTENSION_RE = /\.(?:avif|bmp|css|gif|ico|jpeg|jpg|js|json|map|mp4|pdf|png|svg|webp|woff2?)$/i;
-var JSX_ROUTE_PATH_RE = /<(?:Route|[A-Z][\w.]*Route)\b[^>]*\bpath\s*=\s*(?:"([^"]+)"|'([^']+)'|{\s*"([^"]+)"\s*}|{\s*'([^']+)'\s*}|{\s*`([^`]+)`\s*})/g;
-var OBJECT_ROUTE_PATH_RE = /\bpath\s*:\s*(?:"([^"]+)"|'([^']+)'|`([^`]+)`)/g;
-var STATIC_HTML_ENTRY_FILES = [
-  "index.html",
-  "docs/index.html",
-  "src/index.html",
-  "public/index.html",
-  "dist/index.html"
-];
-var STATIC_HTML_ROUTE_DIRS = ["demos", "examples"];
-var MAX_STATIC_HTML_CANDIDATES = 1e3;
-var MAX_FILE_READ_BYTES = 512 * 1024;
-var MAX_WALK_FILES = 5e3;
-var MAX_REPORT_ROUTES = 80;
-var SKIP_DIRS = /* @__PURE__ */ new Set([
+var MAX_FILE_READ_BYTES2 = 512 * 1024;
+var MAX_WALK_FILES2 = 5e3;
+var MAX_REPORT_ROUTES2 = 80;
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   ".git",
   ".next",
   ".nuxt",
@@ -2406,17 +3198,6 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "target",
   "vendor"
 ]);
-var RULE_FILES = [
-  "CLAUDE.md",
-  "AGENTS.md",
-  "GEMINI.md",
-  ".cursorrules",
-  ".cursor/rules",
-  ".claude/rules",
-  ".github/copilot-instructions.md",
-  "copilot-instructions.md",
-  ".windsurfrules"
-];
 var GITHUB_OWNER_RE = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?$/i;
 var GITHUB_REPO_RE = /^[a-z0-9._-]{1,100}$/i;
 function parseHttpUrl(value) {
@@ -2449,150 +3230,64 @@ var WEB_FRAMEWORKS = /* @__PURE__ */ new Set([
   "svelte",
   "vue"
 ]);
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readTextFile(path, maxBytes = MAX_FILE_READ_BYTES) {
+function readTextFile2(path, maxBytes = MAX_FILE_READ_BYTES2) {
   try {
-    const stat = statSync2(path);
+    const stat = statSync3(path);
     if (!stat.isFile() || stat.size > maxBytes) return null;
-    return readFileSync4(path, "utf-8");
+    return readFileSync5(path, "utf-8");
   } catch {
     return null;
   }
 }
-function readPackageJson(projectRoot) {
-  const path = join3(projectRoot, "package.json");
-  if (!existsSync3(path)) return { value: null, present: false, valid: false };
-  const content = readTextFile(path);
+function readPackageJson2(projectRoot) {
+  const path = join4(projectRoot, "package.json");
+  if (!existsSync4(path)) return { value: null, present: false, valid: false };
+  const content = readTextFile2(path);
   if (!content) return { value: null, present: true, valid: false };
   try {
     const parsed = JSON.parse(content);
     return {
-      value: isRecord(parsed) ? parsed : null,
+      value: isRecord2(parsed) ? parsed : null,
       present: true,
-      valid: isRecord(parsed)
+      valid: isRecord2(parsed)
     };
   } catch {
-    return { value: null, present: true, valid: false };
-  }
-}
-function dependencyVersion(dependencies, names) {
-  for (const name of names) {
-    const version = dependencies[name];
-    if (version) return version.replace(/^[~^]/, "");
-  }
-  return null;
-}
-function hasAnyFile(projectRoot, paths) {
-  return paths.some((path) => existsSync3(join3(projectRoot, path)));
-}
-function hasStaticHtmlSurface(projectRoot) {
-  if (hasAnyFile(projectRoot, STATIC_HTML_ENTRY_FILES)) return true;
-  return STATIC_HTML_ROUTE_DIRS.some((dir) => existsSync3(join3(projectRoot, dir, "index.html")));
-}
-function detectPackageManager(projectRoot, pkg) {
-  const declared = pkg?.packageManager?.split("@")[0];
-  if (declared === "npm" || declared === "pnpm" || declared === "yarn" || declared === "bun") {
-    return declared;
-  }
-  if (existsSync3(join3(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync3(join3(projectRoot, "yarn.lock"))) return "yarn";
-  if (existsSync3(join3(projectRoot, "bun.lockb"))) return "bun";
-  if (existsSync3(join3(projectRoot, "package-lock.json"))) return "npm";
-  return "unknown";
-}
-function detectPrimaryLanguage(projectRoot, packageJsonPresent) {
-  if (packageJsonPresent) return hasStaticHtmlSurface(projectRoot) ? "html" : "javascript";
-  if (hasAnyFile(projectRoot, ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile"]))
-    return "python";
-  if (hasAnyFile(projectRoot, ["go.mod"])) return "go";
-  if (hasAnyFile(projectRoot, ["Cargo.toml"])) return "rust";
-  if (hasStaticHtmlSurface(projectRoot)) return "html";
-  return "unknown";
-}
-function detectProject(projectRoot) {
-  const packageRead = readPackageJson(projectRoot);
-  const pkg = packageRead.value;
-  const dependencies = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
-  let framework = "unknown";
-  let frameworkVersion = null;
-  if (hasAnyFile(projectRoot, ["next.config.js", "next.config.ts", "next.config.mjs"]) || dependencies.next) {
-    framework = "nextjs";
-    frameworkVersion = dependencyVersion(dependencies, ["next"]);
-  } else if (hasAnyFile(projectRoot, ["nuxt.config.js", "nuxt.config.ts"]) || dependencies.nuxt) {
-    framework = "nuxt";
-    frameworkVersion = dependencyVersion(dependencies, ["nuxt"]);
-  } else if (hasAnyFile(projectRoot, ["astro.config.mjs", "astro.config.ts"]) || dependencies.astro) {
-    framework = "astro";
-    frameworkVersion = dependencyVersion(dependencies, ["astro"]);
-  } else if (hasAnyFile(projectRoot, ["svelte.config.js", "svelte.config.ts"]) || dependencies.svelte || dependencies["@sveltejs/kit"]) {
-    framework = "svelte";
-    frameworkVersion = dependencyVersion(dependencies, ["svelte", "@sveltejs/kit"]);
-  } else if (hasAnyFile(projectRoot, ["angular.json"]) || dependencies["@angular/core"]) {
-    framework = "angular";
-    frameworkVersion = dependencyVersion(dependencies, ["@angular/core"]);
-  } else if (dependencies["solid-js"]) {
-    framework = "solid";
-    frameworkVersion = dependencyVersion(dependencies, ["solid-js"]);
-  } else if (dependencies.vue) {
-    framework = "vue";
-    frameworkVersion = dependencyVersion(dependencies, ["vue"]);
-  } else if (dependencies.react) {
-    framework = "react";
-    frameworkVersion = dependencyVersion(dependencies, ["react"]);
-  } else if (hasStaticHtmlSurface(projectRoot)) {
-    framework = "html";
-  }
-  return {
-    framework,
-    frameworkVersion,
-    packageManager: detectPackageManager(projectRoot, pkg),
-    primaryLanguage: detectPrimaryLanguage(projectRoot, packageRead.present),
-    hasTypeScript: hasAnyFile(projectRoot, ["tsconfig.json"]),
-    hasTailwind: hasAnyFile(projectRoot, [
-      "tailwind.config.js",
-      "tailwind.config.ts",
-      "tailwind.config.mjs",
-      "tailwind.config.cjs"
-    ]),
-    hasDecantr: existsSync3(join3(projectRoot, "decantr.essence.json")) || existsSync3(join3(projectRoot, ".decantr")) || Boolean(dependencies["@decantr/cli"] || dependencies["@decantr/css"]),
-    packageName: typeof pkg?.name === "string" ? pkg.name : null,
-    packageJsonValid: packageRead.valid,
-    packageJsonPresent: packageRead.present,
-    dependencies
-  };
+    return { value: null, present: true, valid: false };
+  }
 }
-function shouldSkipDir(name) {
-  return SKIP_DIRS.has(name) || name.startsWith(".") && name !== ".github";
+function shouldSkipDir2(name) {
+  return SKIP_DIRS2.has(name) || name.startsWith(".") && name !== ".github";
 }
-function walkFiles(projectRoot, options = {}) {
+function walkFiles2(projectRoot, options = {}) {
   const files = [];
   function walk(dir) {
-    if (files.length >= MAX_WALK_FILES) return;
+    if (files.length >= MAX_WALK_FILES2) return;
     let entries;
     try {
-      entries = readdirSync3(dir);
+      entries = readdirSync4(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
-      if (files.length >= MAX_WALK_FILES) return;
-      const fullPath = join3(dir, entry);
+      if (files.length >= MAX_WALK_FILES2) return;
+      const fullPath = join4(dir, entry);
       let stat;
       try {
-        stat = statSync2(fullPath);
+        stat = statSync3(fullPath);
       } catch {
         continue;
       }
       if (stat.isDirectory()) {
-        if (shouldSkipDir(entry) && !options.includeHidden) continue;
+        if (shouldSkipDir2(entry) && !options.includeHidden) continue;
         walk(fullPath);
         continue;
       }
       if (!stat.isFile()) continue;
-      const rel = relative3(projectRoot, fullPath).replace(/\\/g, "/");
-      const ext = extname3(entry).toLowerCase();
+      const rel = relative4(projectRoot, fullPath).replace(/\\/g, "/");
+      const ext = extname4(entry).toLowerCase();
       if (!options.extensions || options.extensions.has(ext)) {
         files.push(rel);
       }
@@ -2601,347 +3296,8 @@ function walkFiles(projectRoot, options = {}) {
   walk(projectRoot);
   return files;
 }
-function segmentToRoute(segment) {
-  if (segment.startsWith("(") && segment.endsWith(")")) return null;
-  if (segment.startsWith("[") && segment.endsWith("]")) {
-    const param = segment.slice(1, -1);
-    if (param.startsWith("...")) return `:${param.slice(3)}*`;
-    if (param.startsWith("[...") && param.endsWith("]")) return `:${param.slice(4, -1)}*`;
-    return `:${param}`;
-  }
-  return segment;
-}
-function walkNextAppRoutes(dir, projectRoot, segments) {
-  let entries;
-  try {
-    entries = readdirSync3(dir);
-  } catch {
-    return [];
-  }
-  const routes = [];
-  const pageFile = entries.find((entry) => /^page\.(tsx|ts|jsx|js)$/.test(entry));
-  const hasLayout = entries.some((entry) => /^layout\.(tsx|ts|jsx|js)$/.test(entry));
-  if (pageFile) {
-    routes.push({
-      path: `/${segments.filter(Boolean).join("/")}` || "/",
-      file: relative3(projectRoot, join3(dir, pageFile)).replace(/\\/g, "/"),
-      hasLayout
-    });
-  }
-  for (const entry of entries) {
-    if (shouldSkipDir(entry)) continue;
-    const fullPath = join3(dir, entry);
-    try {
-      if (!statSync2(fullPath).isDirectory()) continue;
-    } catch {
-      continue;
-    }
-    const routeSegment = segmentToRoute(entry);
-    routes.push(
-      ...walkNextAppRoutes(
-        fullPath,
-        projectRoot,
-        routeSegment === null ? segments : [...segments, routeSegment]
-      )
-    );
-  }
-  return routes;
-}
-function fileRouteFromPath(file, baseDir) {
-  let withoutExt = file.slice(0, -extname3(file).length);
-  if (withoutExt.endsWith("/index")) withoutExt = withoutExt.slice(0, -"/index".length);
-  withoutExt = withoutExt.replace(
-    new RegExp(`^${baseDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`),
-    ""
-  );
-  const parts = withoutExt.split("/").filter(Boolean).map((part) => segmentToRoute(part)).filter(Boolean);
-  return `/${parts.join("/")}` || "/";
-}
-function scanFileRoutes(projectRoot, baseDir, extensions = PAGE_EXTENSIONS) {
-  const fullBase = join3(projectRoot, baseDir);
-  if (!existsSync3(fullBase)) return [];
-  return walkFiles(fullBase, { extensions }).flatMap((file) => {
-    const baseName = file.split("/").pop() ?? file;
-    const routeFileName = baseName.slice(0, -extname3(baseName).length);
-    if (routeFileName.startsWith("_")) return [];
-    const rel = relative3(projectRoot, join3(fullBase, file)).replace(/\\/g, "/");
-    return [{ path: fileRouteFromPath(rel, baseDir), file: rel, hasLayout: false }];
-  });
-}
-function scanReactRouter(projectRoot) {
-  const files = walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS });
-  const routes = /* @__PURE__ */ new Map();
-  let hashRouting = false;
-  for (const file of files) {
-    const content = readTextFile(join3(projectRoot, file));
-    if (!content) continue;
-    if (content.includes("HashRouter") || content.includes("createHashRouter")) hashRouting = true;
-    for (const match of content.matchAll(JSX_ROUTE_PATH_RE)) {
-      const literal = firstRouteLiteralMatch(match);
-      for (const route of normalizeDetectedRouteLiterals(literal || "/")) {
-        routes.set(route, { path: route, file, hasLayout: false });
-      }
-    }
-    for (const match of content.matchAll(OBJECT_ROUTE_PATH_RE)) {
-      const literal = firstRouteLiteralMatch(match);
-      for (const route of normalizeDetectedRouteLiterals(literal || "/")) {
-        routes.set(route, { path: route, file, hasLayout: false });
-      }
-    }
-    for (const route of detectPathnameBranchRoutes(content)) {
-      routes.set(route, { path: route, file, hasLayout: false });
-    }
-    for (const route of detectDeclarativeRouteSpecRoutes(content)) {
-      routes.set(route, { path: route, file, hasLayout: false });
-    }
-  }
-  return { routes: [...routes.values()], hashRouting };
-}
-function firstRouteLiteralMatch(match) {
-  return match.slice(1).find((value) => typeof value === "string") ?? null;
-}
-function normalizeDetectedRouteLiterals(value) {
-  const withoutHash = value.trim().split("#")[0];
-  const cleaned = withoutHash.includes("?") && !withoutHash.endsWith(")?") ? withoutHash.split("?")[0] : withoutHash;
-  if (!cleaned || cleaned === "/") return ["/"];
-  if (cleaned === "*" || cleaned === "**" || cleaned.startsWith("#")) return [];
-  if (cleaned === "/*" || cleaned === "/**") return [];
-  if (!cleaned.startsWith("/") || cleaned.startsWith("//")) return [];
-  if (ROUTE_ASSET_EXTENSION_RE.test(cleaned)) return [];
-  const optionalGroup = cleaned.match(/^\/\(([^()]+)\)\?$/);
-  if (optionalGroup) {
-    return [
-      "/",
-      ...optionalGroup[1].split("|").map((segment) => segment.trim()).filter(Boolean).map((segment) => `/${segment}`)
-    ];
-  }
-  const withoutTrailingWildcard = cleaned.endsWith("*") && !cleaned.endsWith("/*") && !/:\w+\*$/.test(cleaned) ? cleaned.slice(0, -1) : cleaned;
-  const normalized = withoutTrailingWildcard.replace(/\/+$/g, "") || "/";
-  if (normalized === "/*" || normalized === "/**") return [];
-  return [normalized];
-}
-function collectRouteLiterals(pattern, content, routes) {
-  let count = 0;
-  for (const match of content.matchAll(pattern)) {
-    for (const route of normalizeDetectedRouteLiterals(match[1] ?? "")) {
-      routes.add(route);
-      count += 1;
-    }
-  }
-  return count;
-}
-function htmlRouteFromFile(file) {
-  let withoutExt = file.slice(0, -extname3(file).length).replace(/\\/g, "/");
-  if (withoutExt.endsWith("/index")) withoutExt = withoutExt.slice(0, -"/index".length);
-  if (withoutExt === "index" || withoutExt === "docs" || withoutExt === "src" || withoutExt === "public" || withoutExt === "dist") {
-    return "/";
-  }
-  return `/${withoutExt.split("/").filter(Boolean).join("/")}` || "/";
-}
-function collectStaticHtmlFiles(dir, projectRoot, files, depth = 0) {
-  if (depth > 5 || files.length >= MAX_STATIC_HTML_CANDIDATES) return;
-  let entries;
-  try {
-    entries = readdirSync3(dir).sort();
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (files.length >= MAX_STATIC_HTML_CANDIDATES) return;
-    if (entry.startsWith(".") || entry === "node_modules") continue;
-    const fullPath = join3(dir, entry);
-    try {
-      const stat = statSync2(fullPath);
-      if (stat.isDirectory()) {
-        collectStaticHtmlFiles(fullPath, projectRoot, files, depth + 1);
-      } else if (stat.isFile() && /\.(?:html|htm)$/i.test(entry)) {
-        files.push(relative3(projectRoot, fullPath).replace(/\\/g, "/"));
-      }
-    } catch {
-    }
-  }
-}
-function staticHtmlFilePriority(file) {
-  const base = file.split("/").pop()?.toLowerCase();
-  if (base === "index.html" || base === "index.htm") return 0;
-  if (base === "default.html" || base === "default.htm") return 1;
-  return 2;
-}
-function scanStaticHtmlRoutes(projectRoot) {
-  const routes = /* @__PURE__ */ new Map();
-  for (const file of STATIC_HTML_ENTRY_FILES) {
-    if (!existsSync3(join3(projectRoot, file))) continue;
-    routes.set("/", { path: "/", file, hasLayout: false });
-    break;
-  }
-  for (const dir of STATIC_HTML_ROUTE_DIRS) {
-    const fullDir = join3(projectRoot, dir);
-    if (!existsSync3(fullDir)) continue;
-    const files = [];
-    collectStaticHtmlFiles(fullDir, projectRoot, files);
-    for (const file of files.sort(
-      (a, b) => staticHtmlFilePriority(a) - staticHtmlFilePriority(b) || a.localeCompare(b)
-    )) {
-      const routePath = htmlRouteFromFile(file);
-      if (routes.has(routePath)) continue;
-      routes.set(routePath, { path: routePath, file, hasLayout: false });
-    }
-  }
-  return [...routes.values()].slice(0, MAX_REPORT_ROUTES);
-}
-function detectPathnameBranchRoutes(content) {
-  const routes = /* @__PURE__ */ new Set();
-  const comparison = new RegExp(
-    `\\b${ROUTE_VARIABLE_NAMES}\\b\\s*(?:===|!==|==|!=)\\s*["'\`](\\/[^"'\`]+)["'\`]`,
-    "g"
-  );
-  const reversedComparison = new RegExp(
-    `["'\`](\\/[^"'\`]+)["'\`]\\s*(?:===|!==|==|!=)\\s*\\b${ROUTE_VARIABLE_NAMES}\\b`,
-    "g"
-  );
-  const strongMatches = collectRouteLiterals(comparison, content, routes) + collectRouteLiterals(reversedComparison, content, routes) + collectRouteLiterals(/\bcase\s+["'`](\/[^"'`]+)["'`]\s*:/g, content, routes);
-  const hasPathnameSignal = /\b(?:window\.|document\.)?location\.pathname\b|\bpathname\b/.test(
-    content
-  );
-  if (strongMatches > 0 || hasPathnameSignal) {
-    collectRouteLiterals(/\b(?:href|to)\s*=\s*["'`](\/[^"'`]+)["'`]/g, content, routes);
-  }
-  return [...routes];
-}
-function detectDeclarativeRouteSpecRoutes(content) {
-  const routes = /* @__PURE__ */ new Set();
-  const hasRouteSpecSignal = content.includes("@wasp.sh/spec") || /\b(?:const|export\s+const)\s+\w*Spec\b/.test(content) || /\bapp\s*\(\s*\{[\s\S]*\bspec\s*:/.test(content);
-  if (!hasRouteSpecSignal) return [];
-  collectRouteLiterals(
-    /\broute\s*\(\s*["'`][^"'`]*["'`]\s*,\s*["'`](\/[^"'`]*)["'`]\s*,\s*page\s*\(/g,
-    content,
-    routes
-  );
-  return [...routes];
-}
-function scanRoutes(projectRoot, detection) {
-  const appRoutes = ["src/app", "app"].flatMap(
-    (dir) => existsSync3(join3(projectRoot, dir)) ? walkNextAppRoutes(join3(projectRoot, dir), projectRoot, []) : []
-  );
-  const pagesRoutes = ["src/pages", "pages"].flatMap((dir) => scanFileRoutes(projectRoot, dir));
-  if (detection.framework === "nextjs") {
-    if (appRoutes.length > 0 && pagesRoutes.length > 0)
-      return { strategy: "mixed-next-router", routes: [...appRoutes, ...pagesRoutes] };
-    if (appRoutes.length > 0) return { strategy: "app-router", routes: appRoutes };
-    if (pagesRoutes.length > 0) return { strategy: "pages-router", routes: pagesRoutes };
-  }
-  if (detection.framework === "svelte") {
-    const routes = scanFileRoutes(projectRoot, "src/routes", /* @__PURE__ */ new Set([".svelte", ".ts", ".js"]));
-    if (routes.length > 0) return { strategy: "sveltekit-router", routes };
-  }
-  if (detection.framework === "nuxt") {
-    const routes = ["pages", "app/pages"].flatMap(
-      (dir) => scanFileRoutes(projectRoot, dir, /* @__PURE__ */ new Set([".vue"]))
-    );
-    if (routes.length > 0) return { strategy: "nuxt-router", routes };
-  }
-  if (detection.framework === "vue") {
-    const router = scanReactRouter(projectRoot);
-    if (router.routes.length > 0) return { strategy: "vue-router", routes: router.routes };
-  }
-  const reactRouter = scanReactRouter(projectRoot);
-  if (reactRouter.routes.length > 0)
-    return { strategy: "react-router", routes: reactRouter.routes };
-  if (pagesRoutes.length > 0) return { strategy: "pages-router", routes: pagesRoutes };
-  const staticHtmlRoutes = scanStaticHtmlRoutes(projectRoot);
-  if (staticHtmlRoutes.length > 0) return { strategy: "static-html", routes: staticHtmlRoutes };
-  return { strategy: "none", routes: [] };
-}
-function countComponents(projectRoot, routes) {
-  const sourceFiles = walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS });
-  const componentFiles = sourceFiles.filter((file) => {
-    const base = file.split("/").pop() ?? file;
-    return /^[A-Z][\w-]*\.(tsx|ts|jsx|js|vue|svelte)$/.test(base);
-  });
-  const directories = [
-    ...new Set(
-      componentFiles.map((file) => file.split("/").slice(0, -1).join("/")).filter(Boolean)
-    )
-  ].slice(0, 16);
-  return {
-    pageCount: routes.routes.length,
-    componentCount: componentFiles.length,
-    directories
-  };
-}
-function extractCssEvidence(content) {
-  const variableMatches = [...content.matchAll(/--[\w-]+\s*:/g)];
-  const colorMatches = [...content.matchAll(/#[0-9a-fA-F]{3,8}\b|rgb[a]?\(|hsl[a]?\(/g)];
-  const themeSignals = /* @__PURE__ */ new Set();
-  if (/\bdark\b|color-scheme:\s*dark|\[data-theme=['"]dark['"]|\.dark\b/.test(content))
-    themeSignals.add("dark mode");
-  if (/\[data-theme=|data-theme|theme-\w+/.test(content)) themeSignals.add("theme selector");
-  if (/prefers-color-scheme/.test(content)) themeSignals.add("system color preference");
-  return {
-    variables: variableMatches.length,
-    colors: colorMatches.length,
-    dark: themeSignals.has("dark mode") || themeSignals.has("system color preference"),
-    themeSignals: [...themeSignals]
-  };
-}
-function scanStyling(projectRoot, detection) {
-  const deps = detection.dependencies;
-  const cssFiles = walkFiles(projectRoot, { extensions: STYLE_EXTENSIONS });
-  const themeSignals = /* @__PURE__ */ new Set();
-  let cssVariableCount = 0;
-  let colorTokenCount = 0;
-  let darkMode = false;
-  let configFile = null;
-  let approach = "unknown";
-  const tailwindConfig = [
-    "tailwind.config.js",
-    "tailwind.config.ts",
-    "tailwind.config.mjs",
-    "tailwind.config.cjs"
-  ].find((file) => existsSync3(join3(projectRoot, file)));
-  if (tailwindConfig || deps.tailwindcss) {
-    approach = "tailwind";
-    configFile = tailwindConfig ?? "package.json";
-  } else if (deps["@decantr/css"] || existsSync3(join3(projectRoot, "src/styles/tokens.css")) && existsSync3(join3(projectRoot, "src/styles/treatments.css"))) {
-    approach = "decantr-css";
-    configFile = deps["@decantr/css"] ? "package.json" : "src/styles/tokens.css";
-  } else if (deps.bootstrap) {
-    approach = "bootstrap";
-    configFile = "package.json";
-  } else if (deps["@mui/material"]) {
-    approach = "mui";
-    configFile = "package.json";
-  } else if (deps["@chakra-ui/react"]) {
-    approach = "chakra";
-    configFile = "package.json";
-  } else if (cssFiles.some((file) => file.endsWith(".module.css"))) {
-    approach = "css-modules";
-  } else if (cssFiles.length > 0) {
-    approach = "css";
-  }
-  for (const file of cssFiles.slice(0, 80)) {
-    const content = readTextFile(join3(projectRoot, file), 256 * 1024);
-    if (!content) continue;
-    const evidence = extractCssEvidence(content);
-    cssVariableCount += evidence.variables;
-    colorTokenCount += evidence.colors;
-    darkMode ||= evidence.dark;
-    for (const signal of evidence.themeSignals) themeSignals.add(signal);
-  }
-  return {
-    approach,
-    configFile,
-    cssVariableCount,
-    colorTokenCount,
-    darkMode,
-    themeSignals: [...themeSignals]
-  };
-}
-function findAssistantRules(projectRoot) {
-  return RULE_FILES.filter((file) => existsSync3(join3(projectRoot, file)));
-}
 function scanStaticHosting(projectRoot, detection) {
-  const packageRead = readPackageJson(projectRoot);
+  const packageRead = readPackageJson2(projectRoot);
   const pkg = packageRead.value;
   const evidence = [];
   const homepageUrl = typeof pkg?.homepage === "string" ? pkg.homepage : null;
@@ -2955,27 +3311,27 @@ function scanStaticHosting(projectRoot, detection) {
   if (detection.dependencies["gh-pages"] || pkg?.scripts?.deploy?.includes("gh-pages")) {
     evidence.push("package scripts or dependencies reference gh-pages");
   }
-  if (existsSync3(join3(projectRoot, "docs", "index.html")))
+  if (existsSync4(join4(projectRoot, "docs", "index.html")))
     evidence.push("docs/index.html can serve GitHub Pages");
-  if (existsSync3(join3(projectRoot, "404.html")) || existsSync3(join3(projectRoot, "docs", "404.html"))) {
+  if (existsSync4(join4(projectRoot, "404.html")) || existsSync4(join4(projectRoot, "docs", "404.html"))) {
     evidence.push("404.html fallback is present");
   }
-  const workflowDir = join3(projectRoot, ".github", "workflows");
-  if (existsSync3(workflowDir)) {
-    for (const file of walkFiles(workflowDir, { extensions: /* @__PURE__ */ new Set([".yml", ".yaml"]) }).slice(
+  const workflowDir = join4(projectRoot, ".github", "workflows");
+  if (existsSync4(workflowDir)) {
+    for (const file of walkFiles2(workflowDir, { extensions: /* @__PURE__ */ new Set([".yml", ".yaml"]) }).slice(
       0,
       20
     )) {
-      const content = readTextFile(join3(workflowDir, file));
+      const content = readTextFile2(join4(workflowDir, file));
       if (content && /pages|gh-pages|upload-pages-artifact|deploy-pages/i.test(content)) {
         evidence.push(`GitHub Pages workflow hint: .github/workflows/${file}`);
         break;
       }
     }
   }
-  const sourceFiles = walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS });
+  const sourceFiles = walkFiles2(projectRoot, { extensions: SOURCE_EXTENSIONS2 });
   for (const file of sourceFiles.slice(0, 200)) {
-    const content = readTextFile(join3(projectRoot, file), 128 * 1024);
+    const content = readTextFile2(join4(projectRoot, file), 128 * 1024);
     if (!content) continue;
     if (content.includes("HashRouter") || content.includes("createHashRouter")) {
       hashRouting = true;
@@ -2984,7 +3340,7 @@ function scanStaticHosting(projectRoot, detection) {
     }
   }
   for (const config of ["vite.config.ts", "vite.config.js", "vite.config.mjs"]) {
-    const content = readTextFile(join3(projectRoot, config), 128 * 1024);
+    const content = readTextFile2(join4(projectRoot, config), 128 * 1024);
     const baseMatch = content?.match(/\bbase\s*:\s*['"]([^'"]+)['"]/);
     if (baseMatch?.[1]) {
       basePath = baseMatch[1];
@@ -3029,33 +3385,6 @@ function buildApplicability(detection, routes, components) {
     reasons: ["A web framework was detected, but route/component evidence is thin."]
   };
 }
-function buildConfidence(applicability, detection, routes, styling) {
-  let score = 20;
-  const reasons = [];
-  if (detection.packageJsonPresent && detection.packageJsonValid) {
-    score += 15;
-    reasons.push("package.json was readable");
-  }
-  if (WEB_FRAMEWORKS.has(detection.framework)) {
-    score += 25;
-    reasons.push(`${detection.framework} framework signal found`);
-  }
-  if (routes.routes.length > 0) {
-    score += 20;
-    reasons.push(`${routes.routes.length} route signal(s) found`);
-  }
-  if (styling.approach !== "unknown") {
-    score += 10;
-    reasons.push(`${styling.approach} styling signal found`);
-  }
-  if (applicability.status === "not_applicable") score = Math.min(score, 35);
-  const clamped = Math.max(5, Math.min(98, score));
-  return {
-    score: clamped,
-    level: clamped >= 75 ? "high" : clamped >= 45 ? "medium" : "low",
-    reasons: reasons.length > 0 ? reasons : ["Only weak project signals were found."]
-  };
-}
 function buildFindings(input) {
   const findings = [];
   const { detection, routes, styling, hosting, assistantRules, applicability, pagesProbe } = input;
@@ -3174,22 +3503,89 @@ function buildCommands(applicability) {
   }
   return commands;
 }
+function routeFromDiscovery(route) {
+  return {
+    path: route.path,
+    file: route.file,
+    hasLayout: route.hasLayout
+  };
+}
+function routeSignalFromDiscovery(signal) {
+  return {
+    path: signal.path,
+    file: signal.file,
+    kind: signal.kind,
+    confidence: signal.confidence,
+    taskable: signal.taskable,
+    evidence: signal.evidence
+  };
+}
+function componentFromDiscovery(component) {
+  return {
+    name: component.name,
+    file: component.file,
+    kind: component.kind,
+    confidence: component.confidence
+  };
+}
+function detectionFromDiscovery(discovery) {
+  return {
+    framework: discovery.project.framework,
+    frameworkVersion: discovery.project.frameworkVersion,
+    packageManager: discovery.project.packageManager,
+    primaryLanguage: discovery.project.primaryLanguage,
+    hasTypeScript: discovery.project.hasTypeScript,
+    hasTailwind: discovery.project.hasTailwind,
+    hasDecantr: discovery.project.hasDecantr,
+    packageName: discovery.project.packageName,
+    packageJsonValid: discovery.project.packageJsonValid,
+    packageJsonPresent: discovery.project.packageJsonPresent,
+    dependencies: discovery.project.dependencies
+  };
+}
+function scanDiscoverySummary(discovery) {
+  return {
+    schemaVersion: "discovery.v1",
+    workspace: {
+      projectPath: discovery.workspace.projectPath,
+      scope: discovery.workspace.scope
+    },
+    projectEvidence: discovery.project.evidence,
+    routeSignalCount: discovery.routes.routeSignalCount,
+    taskableRouteCount: discovery.routes.taskableRouteCount,
+    routeConfidence: discovery.routes.confidence,
+    componentConfidence: discovery.components.confidence,
+    componentEvidence: discovery.components.evidence,
+    limitations: discovery.limitations
+  };
+}
 async function scanProject(projectRoot, options = {}) {
-  const detection = detectProject(projectRoot);
-  const routes = scanRoutes(projectRoot, detection);
-  routes.routes = routes.routes.slice(0, MAX_REPORT_ROUTES);
-  const components = countComponents(projectRoot, routes);
-  const styling = scanStyling(projectRoot, detection);
-  const assistantRules = findAssistantRules(projectRoot);
+  const discovery = discoverProject(projectRoot);
+  const detection = detectionFromDiscovery(discovery);
+  const routes = {
+    strategy: discovery.routes.strategy,
+    routes: discovery.routes.taskableRoutes.map(routeFromDiscovery).slice(0, MAX_REPORT_ROUTES2)
+  };
+  const components = {
+    pageCount: discovery.components.pageCount,
+    componentCount: discovery.components.componentCount,
+    directories: discovery.components.directories,
+    confidence: discovery.components.confidence,
+    evidence: discovery.components.evidence,
+    items: discovery.components.items.map(componentFromDiscovery),
+    limitations: discovery.components.limitations
+  };
+  const styling = discovery.styling;
+  const assistantRules = discovery.assistant.ruleFiles;
   const staticHosting = scanStaticHosting(projectRoot, detection);
   const pagesProbe = options.pagesProbe ?? null;
   const applicability = buildApplicability(detection, routes, components);
-  const confidence = buildConfidence(applicability, detection, routes, styling);
+  const confidence = discovery.confidence;
   const rawInput = options.input ?? { kind: "local", value: "." };
   const input = rawInput.kind === "local" && isAbsolute(rawInput.value) ? { ...rawInput, value: "." } : rawInput;
   return {
-    $schema: SCAN_REPORT_SCHEMA_URL,
-    schemaVersion: "scan-report.v1",
+    $schema: SCAN_REPORT_V2_SCHEMA_URL,
+    schemaVersion: "scan-report.v2",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     input,
     source: {
@@ -3206,12 +3602,19 @@ async function scanProject(projectRoot, options = {}) {
       hasTypeScript: detection.hasTypeScript,
       hasTailwind: detection.hasTailwind,
       hasDecantr: detection.hasDecantr,
-      packageName: detection.packageName
+      packageName: detection.packageName,
+      evidence: discovery.project.evidence,
+      workspaceScope: discovery.workspace.scope,
+      projectPath: discovery.workspace.projectPath
     },
     routes: {
       strategy: routes.strategy,
       count: routes.routes.length,
-      items: routes.routes
+      items: routes.routes,
+      routeSignalCount: discovery.routes.routeSignalCount,
+      taskableRouteCount: discovery.routes.taskableRouteCount,
+      confidence: discovery.routes.confidence,
+      signals: discovery.routes.routeSignals.map(routeSignalFromDiscovery)
     },
     components,
     styling,
@@ -3220,6 +3623,7 @@ async function scanProject(projectRoot, options = {}) {
       ruleFiles: assistantRules
     },
     pagesProbe,
+    discovery: scanDiscoverySummary(discovery),
     findings: buildFindings({
       detection,
       routes,
@@ -3234,7 +3638,7 @@ async function scanProject(projectRoot, options = {}) {
       sourceUploaded: input.kind !== "local",
       persistedByDecantr: false,
       notes: [
-        "V1 scans are read-only and do not install dependencies, build projects, execute scripts, or open pull requests.",
+        "V2 scans are read-only and do not install dependencies, build projects, execute scripts, or open pull requests.",
         "Hosted scans use temporary public-repo checkouts and return an ephemeral report."
       ]
     }
@@ -3242,8 +3646,8 @@ async function scanProject(projectRoot, options = {}) {
 }
 function createUnavailableScanReport(input) {
   return {
-    $schema: SCAN_REPORT_SCHEMA_URL,
-    schemaVersion: "scan-report.v1",
+    $schema: SCAN_REPORT_V2_SCHEMA_URL,
+    schemaVersion: "scan-report.v2",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     input: input.scanInput,
     source: {
@@ -3268,10 +3672,29 @@ function createUnavailableScanReport(input) {
       hasTypeScript: false,
       hasTailwind: false,
       hasDecantr: false,
-      packageName: null
+      packageName: null,
+      evidence: [],
+      workspaceScope: "single-app",
+      projectPath: "."
+    },
+    routes: {
+      strategy: "none",
+      count: 0,
+      items: [],
+      routeSignalCount: 0,
+      taskableRouteCount: 0,
+      confidence: "low",
+      signals: []
+    },
+    components: {
+      pageCount: 0,
+      componentCount: 0,
+      directories: [],
+      confidence: "low",
+      evidence: [],
+      items: [],
+      limitations: ["Source could not be inspected."]
     },
-    routes: { strategy: "none", count: 0, items: [] },
-    components: { pageCount: 0, componentCount: 0, directories: [] },
     styling: {
       approach: "unknown",
       configFile: null,
@@ -3289,6 +3712,20 @@ function createUnavailableScanReport(input) {
     },
     assistant: { ruleFiles: [] },
     pagesProbe: input.pagesProbe ?? null,
+    discovery: {
+      schemaVersion: "discovery.v1",
+      workspace: {
+        projectPath: ".",
+        scope: "single-app"
+      },
+      projectEvidence: [],
+      routeSignalCount: 0,
+      taskableRouteCount: 0,
+      routeConfidence: "low",
+      componentConfidence: "low",
+      componentEvidence: [],
+      limitations: ["Source could not be inspected."]
+    },
     findings: [
       {
         id: "source-unavailable",
@@ -3333,7 +3770,7 @@ async function probePublishedSite(url, options = {}) {
         "User-Agent": "Decantr-Scan/1.0 (+https://decantr.ai/scan)"
       }
     });
-    const text = (await response.text()).slice(0, MAX_FILE_READ_BYTES);
+    const text = (await response.text()).slice(0, MAX_FILE_READ_BYTES2);
     const titleMatch = text.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
     const descriptionTag = text.match(/<meta\b[^>]*(?:name|property)=["']description["'][^>]*>/i)?.[0] ?? null;
     const canonicalTag = text.match(/<link\b[^>]*rel=["']canonical["'][^>]*>/i)?.[0] ?? null;
@@ -3434,8 +3871,8 @@ function resolveGitHubScanInput(input) {
 import * as ts4 from "typescript";
 
 // src/source/inventory.ts
-import { existsSync as existsSync4, readdirSync as readdirSync4, realpathSync, statSync as statSync3 } from "fs";
-import { extname as extname4, isAbsolute as isAbsolute2, join as join4, relative as relative4, resolve } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync5, realpathSync, statSync as statSync4 } from "fs";
+import { extname as extname5, isAbsolute as isAbsolute2, join as join5, relative as relative5, resolve as resolve2 } from "path";
 import * as ts3 from "typescript";
 var DEFAULT_MAX_FILES = 5e3;
 var DEFAULT_MAX_FILE_SIZE_BYTES = 512 * 1024;
@@ -3466,7 +3903,7 @@ function normalizeSourcePath(path) {
   return path.replace(/\\/g, "/");
 }
 function isPathInsideProject(projectRoot, absolutePath) {
-  const normalizedRelative = normalizeSourcePath(relative4(projectRoot, absolutePath));
+  const normalizedRelative = normalizeSourcePath(relative5(projectRoot, absolutePath));
   return normalizedRelative === "" || !normalizedRelative.startsWith("../") && normalizedRelative !== "..";
 }
 function isSupportedSourceExtension(extension, extensions) {
@@ -3474,7 +3911,7 @@ function isSupportedSourceExtension(extension, extensions) {
   return extensions ? extensions.map((entry) => entry.toLowerCase()).includes(normalized) : DEFAULT_EXTENSIONS.has(normalized);
 }
 function sourceKindFromPath(path) {
-  const extension = extname4(path).toLowerCase();
+  const extension = extname5(path).toLowerCase();
   switch (extension) {
     case ".ts":
       return "ts";
@@ -3538,12 +3975,12 @@ function shouldSkipFile(relativePath, options) {
   return false;
 }
 function inventoryFile(projectRoot, absolutePath) {
-  const extension = extname4(absolutePath).toLowerCase();
+  const extension = extname5(absolutePath).toLowerCase();
   const kind = sourceKindFromPath(absolutePath);
   const language = sourceLanguageFromPath(absolutePath);
   if (!kind || !language) return null;
-  const relativePath = normalizeSourcePath(relative4(projectRoot, absolutePath) || absolutePath);
-  const sizeBytes = statSync3(absolutePath).size;
+  const relativePath = normalizeSourcePath(relative5(projectRoot, absolutePath) || absolutePath);
+  const sizeBytes = statSync4(absolutePath).size;
   return {
     absolutePath,
     relativePath,
@@ -3562,19 +3999,19 @@ function compareSkipped(a, b) {
   return a.path.localeCompare(b.path) || a.reason.localeCompare(b.reason);
 }
 function createSourceInventory(projectRoot, options = {}) {
-  const root = realpathSync(resolve(projectRoot));
+  const root = realpathSync(resolve2(projectRoot));
   const files = [];
   const seenFiles = /* @__PURE__ */ new Set();
   const skipped = [];
   const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
   const maxFileSizeBytes = options.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
   const requestedRoots = options.roots?.length ? [...options.roots] : ["."];
-  const roots = requestedRoots.map((entry) => isAbsolute2(entry) ? resolve(entry) : resolve(root, entry)).filter((entry) => existsSync4(entry) && isPathInsideProject(root, entry));
+  const roots = requestedRoots.map((entry) => isAbsolute2(entry) ? resolve2(entry) : resolve2(root, entry)).filter((entry) => existsSync5(entry) && isPathInsideProject(root, entry));
   const addSkipped = (path, reason) => {
-    skipped.push({ path: normalizeSourcePath(relative4(root, path) || path), reason });
+    skipped.push({ path: normalizeSourcePath(relative5(root, path) || path), reason });
   };
   const addFile = (absolutePath) => {
-    const normalized = normalizeSourcePath(resolve(absolutePath));
+    const normalized = normalizeSourcePath(resolve2(absolutePath));
     if (seenFiles.has(normalized)) return;
     const sourceFile = inventoryFile(root, absolutePath);
     if (!sourceFile) return;
@@ -3586,16 +4023,16 @@ function createSourceInventory(projectRoot, options = {}) {
       addSkipped(directory, "walk-limit");
       return;
     }
-    const entries = readdirSync4(directory, { withFileTypes: true }).sort(
+    const entries = readdirSync5(directory, { withFileTypes: true }).sort(
       (a, b) => a.name.localeCompare(b.name)
     );
     for (const entry of entries) {
       if (files.length >= maxFiles) {
-        addSkipped(join4(directory, entry.name), "walk-limit");
+        addSkipped(join5(directory, entry.name), "walk-limit");
         continue;
       }
-      const absolutePath = join4(directory, entry.name);
-      const relativePath = normalizeSourcePath(relative4(root, absolutePath) || absolutePath);
+      const absolutePath = join5(directory, entry.name);
+      const relativePath = normalizeSourcePath(relative5(root, absolutePath) || absolutePath);
       if (entry.isSymbolicLink()) {
         addSkipped(absolutePath, "symlink");
         continue;
@@ -3609,13 +4046,13 @@ function createSourceInventory(projectRoot, options = {}) {
         continue;
       }
       if (!entry.isFile()) continue;
-      const extension = extname4(entry.name).toLowerCase();
+      const extension = extname5(entry.name).toLowerCase();
       if (!isSupportedSourceExtension(extension, options.extensions)) continue;
       if (shouldSkipFile(relativePath, options)) {
         addSkipped(absolutePath, "ignored-file");
         continue;
       }
-      const stat = statSync3(absolutePath);
+      const stat = statSync4(absolutePath);
       if (stat.size > maxFileSizeBytes) {
         addSkipped(absolutePath, "oversized");
         continue;
@@ -3628,18 +4065,18 @@ function createSourceInventory(projectRoot, options = {}) {
       addSkipped(rootPath, "walk-limit");
       continue;
     }
-    const stat = statSync3(rootPath);
+    const stat = statSync4(rootPath);
     if (stat.isDirectory()) {
-      const relativeRoot = normalizeSourcePath(relative4(root, rootPath));
+      const relativeRoot = normalizeSourcePath(relative5(root, rootPath));
       if (relativeRoot && shouldSkipDirectory(relativeRoot, options)) {
         addSkipped(rootPath, "ignored-directory");
         continue;
       }
       walk(rootPath);
     } else if (stat.isFile()) {
-      const extension = extname4(rootPath).toLowerCase();
+      const extension = extname5(rootPath).toLowerCase();
       if (!isSupportedSourceExtension(extension, options.extensions)) continue;
-      const relativeFile = normalizeSourcePath(relative4(root, rootPath));
+      const relativeFile = normalizeSourcePath(relative5(root, rootPath));
       if (shouldSkipFile(relativeFile, options)) {
         addSkipped(rootPath, "ignored-file");
         continue;
@@ -3745,8 +4182,8 @@ function extractSourceStringLiterals(sourceFile, options = {}) {
 }
 
 // src/source/program.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
-import { dirname, extname as extname5, isAbsolute as isAbsolute3, join as join5, relative as relative5, resolve as resolve2 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
+import { dirname as dirname2, extname as extname6, isAbsolute as isAbsolute3, join as join6, relative as relative6, resolve as resolve3 } from "path";
 import * as ts5 from "typescript";
 var RESOLUTION_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var DEFAULT_COMPILER_OPTIONS = {
@@ -3766,11 +4203,11 @@ var DEFAULT_COMPILER_OPTIONS = {
 function findProjectTsConfig(projectRoot, tsconfigPath) {
   if (tsconfigPath === null) return null;
   if (tsconfigPath) {
-    const absolutePath = isAbsolute3(tsconfigPath) ? resolve2(tsconfigPath) : resolve2(projectRoot, tsconfigPath);
-    return existsSync5(absolutePath) ? absolutePath : null;
+    const absolutePath = isAbsolute3(tsconfigPath) ? resolve3(tsconfigPath) : resolve3(projectRoot, tsconfigPath);
+    return existsSync6(absolutePath) ? absolutePath : null;
   }
-  const localTsConfig = join5(projectRoot, "tsconfig.json");
-  return existsSync5(localTsConfig) ? localTsConfig : null;
+  const localTsConfig = join6(projectRoot, "tsconfig.json");
+  return existsSync6(localTsConfig) ? localTsConfig : null;
 }
 function fallbackCompilerConfig(tsconfigPath, options, diagnostics = []) {
   return {
@@ -3790,13 +4227,13 @@ function readCompilerConfig(projectRoot, options) {
   if (!tsconfigPath) return fallbackCompilerConfig(null, options);
   const parsedJson = ts5.parseConfigFileTextToJson(
     tsconfigPath,
-    readFileSync5(tsconfigPath, "utf-8")
+    readFileSync6(tsconfigPath, "utf-8")
   );
   if (parsedJson.error) return fallbackCompilerConfig(tsconfigPath, options, [parsedJson.error]);
   const parsed = ts5.parseJsonConfigFileContent(
     parsedJson.config,
     ts5.sys,
-    dirname(tsconfigPath),
+    dirname2(tsconfigPath),
     DEFAULT_COMPILER_OPTIONS,
     tsconfigPath
   );
@@ -3815,7 +4252,7 @@ function readCompilerConfig(projectRoot, options) {
 }
 function inventoryFileByAbsolutePath(inventory) {
   return new Map(
-    inventory.files.map((file) => [normalizeSourcePath(resolve2(file.absolutePath)), file])
+    inventory.files.map((file) => [normalizeSourcePath(resolve3(file.absolutePath)), file])
   );
 }
 function createProjectSourceProgram(projectRoot, options = {}) {
@@ -3838,13 +4275,13 @@ function createProjectSourceProgram(projectRoot, options = {}) {
 }
 function getProjectSourceFile(context, pathOrSourceFile) {
   if (typeof pathOrSourceFile !== "string") return pathOrSourceFile;
-  const absolutePath = isAbsolute3(pathOrSourceFile) ? resolve2(pathOrSourceFile) : resolve2(context.projectRoot, pathOrSourceFile);
+  const absolutePath = isAbsolute3(pathOrSourceFile) ? resolve3(pathOrSourceFile) : resolve3(context.projectRoot, pathOrSourceFile);
   const normalized = normalizeSourcePath(absolutePath);
-  return context.program.getSourceFiles().find((sourceFile) => normalizeSourcePath(resolve2(sourceFile.fileName)) === normalized);
+  return context.program.getSourceFiles().find((sourceFile) => normalizeSourcePath(resolve3(sourceFile.fileName)) === normalized);
 }
 function sourceFileRelativePath(context, sourceFile) {
   return normalizeSourcePath(
-    relative5(context.projectRoot, sourceFile.fileName) || sourceFile.fileName
+    relative6(context.projectRoot, sourceFile.fileName) || sourceFile.fileName
   );
 }
 function sourceLocationLineAndColumn(sourceFile, node) {
@@ -3880,32 +4317,32 @@ function manualResolutionCandidates(context, importerPath, specifier) {
   const candidates = [];
   const addCandidates = (base) => {
     candidates.push(base);
-    if (extname5(base)) return;
+    if (extname6(base)) return;
     for (const extension of RESOLUTION_EXTENSIONS) candidates.push(`${base}${extension}`);
     for (const extension of RESOLUTION_EXTENSIONS) {
-      candidates.push(join5(base, `index${extension}`));
+      candidates.push(join6(base, `index${extension}`));
     }
   };
   if (specifier.startsWith(".") || specifier.startsWith("/")) {
-    const base = specifier.startsWith("/") ? resolve2(context.projectRoot, specifier.slice(1)) : resolve2(dirname(importerPath), specifier);
+    const base = specifier.startsWith("/") ? resolve3(context.projectRoot, specifier.slice(1)) : resolve3(dirname2(importerPath), specifier);
     addCandidates(base);
   } else if (specifier.startsWith("@/")) {
-    addCandidates(resolve2(context.projectRoot, specifier.slice(2)));
-    addCandidates(resolve2(context.projectRoot, "src", specifier.slice(2)));
+    addCandidates(resolve3(context.projectRoot, specifier.slice(2)));
+    addCandidates(resolve3(context.projectRoot, "src", specifier.slice(2)));
   }
   return candidates;
 }
 function resolveFromInventory(context, source, importerPath) {
   const inventoryByPath = inventoryFileByAbsolutePath(context.inventory);
   for (const candidate of manualResolutionCandidates(context, importerPath, source)) {
-    const absolutePath = normalizeSourcePath(resolve2(candidate));
+    const absolutePath = normalizeSourcePath(resolve3(candidate));
     const inventoryFile2 = inventoryByPath.get(absolutePath);
-    if (!inventoryFile2 || !existsSync5(inventoryFile2.absolutePath) || !statSync4(inventoryFile2.absolutePath).isFile()) {
+    if (!inventoryFile2 || !existsSync6(inventoryFile2.absolutePath) || !statSync5(inventoryFile2.absolutePath).isFile()) {
       continue;
     }
     return {
       source,
-      importer: normalizeSourcePath(relative5(context.projectRoot, importerPath) || importerPath),
+      importer: normalizeSourcePath(relative6(context.projectRoot, importerPath) || importerPath),
       kind: "project-local",
       resolvedFileName: inventoryFile2.absolutePath,
       relativePath: inventoryFile2.relativePath,
@@ -3919,9 +4356,9 @@ function resolveFromInventory(context, source, importerPath) {
 }
 function resolveSourceImport(context, importer, source) {
   const sourceFile = getProjectSourceFile(context, importer);
-  const importerPath = sourceFile ? resolve2(sourceFile.fileName) : isAbsolute3(String(importer)) ? resolve2(String(importer)) : resolve2(context.projectRoot, String(importer));
+  const importerPath = sourceFile ? resolve3(sourceFile.fileName) : isAbsolute3(String(importer)) ? resolve3(String(importer)) : resolve3(context.projectRoot, String(importer));
   const importerRelativePath = normalizeSourcePath(
-    relative5(context.projectRoot, importerPath) || importerPath
+    relative6(context.projectRoot, importerPath) || importerPath
   );
   const inventoryByPath = inventoryFileByAbsolutePath(context.inventory);
   const resolved = ts5.resolveModuleName(
@@ -3931,7 +4368,7 @@ function resolveSourceImport(context, importer, source) {
     ts5.sys
   ).resolvedModule;
   if (resolved) {
-    const absolutePath = normalizeSourcePath(resolve2(resolved.resolvedFileName));
+    const absolutePath = normalizeSourcePath(resolve3(resolved.resolvedFileName));
     const inventoryFile2 = inventoryByPath.get(absolutePath);
     if (inventoryFile2 && isPathInsideProject(context.projectRoot, absolutePath)) {
       return {
@@ -3952,7 +4389,7 @@ function resolveSourceImport(context, importer, source) {
       kind: hasExternalPackageShape(source) ? "external" : "unresolved",
       resolvedFileName: resolved.resolvedFileName,
       relativePath: null,
-      extension: extname5(resolved.resolvedFileName).toLowerCase() || null,
+      extension: extname6(resolved.resolvedFileName).toLowerCase() || null,
       isProjectLocal: false,
       isExternal: hasExternalPackageShape(source),
       failed: !hasExternalPackageShape(source)
@@ -4120,10 +4557,10 @@ function resolveSourceSymbolOrigin(context, pathOrSourceFile, localName, options
   if (declarations.length === 0) return null;
   const projectFiles = inventoryFileByAbsolutePath(context.inventory);
   const declaration = declarations.find(
-    (entry) => projectFiles.has(normalizeSourcePath(resolve2(entry.getSourceFile().fileName)))
+    (entry) => projectFiles.has(normalizeSourcePath(resolve3(entry.getSourceFile().fileName)))
   ) ?? declarations[0];
   const declarationFile = declaration.getSourceFile();
-  const declarationPath = normalizeSourcePath(resolve2(declarationFile.fileName));
+  const declarationPath = normalizeSourcePath(resolve3(declarationFile.fileName));
   const projectFile = projectFiles.get(declarationPath);
   const isProjectLocal = Boolean(projectFile);
   if (!isProjectLocal && !options.includeExternal) return null;
@@ -4147,7 +4584,7 @@ var VERIFICATION_SCHEMA_URLS = {
   projectHealth: PROJECT_HEALTH_REPORT_V2_SCHEMA_URL,
   decantrCi: DECANTR_CI_REPORT_V2_SCHEMA_URL,
   evidenceBundle: EVIDENCE_BUNDLE_V2_SCHEMA_URL,
-  scanReport: "https://decantr.ai/schemas/scan-report.v1.json",
+  scanReport: "https://decantr.ai/schemas/scan-report.v2.json",
   workspaceHealth: WORKSPACE_HEALTH_REPORT_V2_SCHEMA_URL,
   fileCritique: "https://decantr.ai/schemas/file-critique-report.v1.json",
   showcaseShortlist: "https://decantr.ai/schemas/showcase-shortlist-report.v1.json"
@@ -4157,16 +4594,16 @@ function hashString(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 16);
 }
 function hashFile(path) {
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   try {
-    return createHash("sha256").update(readFileSync6(path)).digest("hex");
+    return createHash("sha256").update(readFileSync7(path)).digest("hex");
   } catch {
     return null;
   }
 }
 function provenanceEntry(projectRoot, relativePath) {
-  const path = join6(projectRoot, relativePath);
-  if (!existsSync6(path)) {
+  const path = join7(projectRoot, relativePath);
+  if (!existsSync7(path)) {
     return {
       path: relativePath,
       present: false,
@@ -4176,7 +4613,7 @@ function provenanceEntry(projectRoot, relativePath) {
   }
   let generatedAt = null;
   try {
-    generatedAt = statSync5(path).mtime.toISOString();
+    generatedAt = statSync6(path).mtime.toISOString();
   } catch {
     generatedAt = null;
   }
@@ -4188,7 +4625,7 @@ function provenanceEntry(projectRoot, relativePath) {
   };
 }
 function provenanceForPath(projectRoot, path) {
-  const rel = isAbsolute4(path) ? relative6(projectRoot, path).replace(/\\/g, "/") : path;
+  const rel = isAbsolute4(path) ? relative7(projectRoot, path).replace(/\\/g, "/") : path;
   return provenanceEntry(projectRoot, rel && !rel.startsWith("..") ? rel : basename2(path));
 }
 function redactEvidenceText(projectRoot, value) {
@@ -4325,7 +4762,7 @@ function createContractAssertions(projectRoot, audit) {
   const assertions = [];
   const essence = audit?.essence;
   const v4 = essence && isV4(essence) ? essence : null;
-  const contextDir = join6(projectRoot, ".decantr", "context");
+  const contextDir = join7(projectRoot, ".decantr", "context");
   const packManifest = audit?.packManifest ?? null;
   assertions.push(
     assertion({
@@ -4335,7 +4772,7 @@ function createContractAssertions(projectRoot, audit) {
       rule: "essence-present",
       status: essence ? "passed" : "failed",
       message: essence ? "Decantr Essence contract is present." : "No Decantr Essence contract was found.",
-      evidence: [redactEvidenceText(projectRoot, join6(projectRoot, "decantr.essence.json"))],
+      evidence: [redactEvidenceText(projectRoot, join7(projectRoot, "decantr.essence.json"))],
       suggestedFix: essence ? void 0 : "Run `decantr init` or restore decantr.essence.json."
     })
   );
@@ -4408,7 +4845,7 @@ function createContractAssertions(projectRoot, audit) {
       rule: "pack-manifest-present",
       status: packManifest ? "passed" : "failed",
       message: packManifest ? "Compiled execution pack manifest is present." : "Compiled execution pack manifest is missing.",
-      evidence: [redactEvidenceText(projectRoot, join6(contextDir, "pack-manifest.json"))],
+      evidence: [redactEvidenceText(projectRoot, join7(contextDir, "pack-manifest.json"))],
       suggestedFix: packManifest ? void 0 : "Run `decantr registry compile-packs decantr.essence.json --write-context` to hydrate the full context pack bundle."
     })
   );
@@ -4420,21 +4857,21 @@ function createContractAssertions(projectRoot, audit) {
       rule: "review-pack-present",
       status: audit?.reviewPack ? "passed" : "failed",
       message: audit?.reviewPack ? "Compiled review pack is present." : "Compiled review pack is missing.",
-      evidence: [redactEvidenceText(projectRoot, join6(contextDir, "review-pack.json"))],
+      evidence: [redactEvidenceText(projectRoot, join7(contextDir, "review-pack.json"))],
       suggestedFix: audit?.reviewPack ? void 0 : "Run `decantr registry compile-packs decantr.essence.json --write-context` so critique has the compiled review contract."
     })
   );
-  const tokensPath = join6(projectRoot, "src", "styles", "tokens.css");
+  const tokensPath = join7(projectRoot, "src", "styles", "tokens.css");
   assertions.push(
     assertion({
       id: "contract.design-token.tokens-file",
       category: "design-token",
-      severity: existsSync6(tokensPath) ? "info" : "warn",
+      severity: existsSync7(tokensPath) ? "info" : "warn",
       rule: "tokens-file-present",
-      status: existsSync6(tokensPath) ? "passed" : "failed",
-      message: existsSync6(tokensPath) ? "Decantr token CSS file is present." : "Decantr token CSS file was not found.",
+      status: existsSync7(tokensPath) ? "passed" : "failed",
+      message: existsSync7(tokensPath) ? "Decantr token CSS file is present." : "Decantr token CSS file was not found.",
       evidence: [redactEvidenceText(projectRoot, tokensPath)],
-      suggestedFix: existsSync6(tokensPath) ? void 0 : "Run `decantr refresh` or map Decantr tokens into the existing styling system."
+      suggestedFix: existsSync7(tokensPath) ? void 0 : "Run `decantr refresh` or map Decantr tokens into the existing styling system."
     })
   );
   return assertions;
@@ -4447,7 +4884,7 @@ function createEvidenceBundle(input) {
   try {
     resolvedProjectRoot = realpathSync2(input.projectRoot);
   } catch {
-    resolvedProjectRoot = resolve3(input.projectRoot);
+    resolvedProjectRoot = resolve4(input.projectRoot);
   }
   const projectId = `project_${hashString(resolvedProjectRoot)}`;
   return {
@@ -4585,21 +5022,21 @@ function scoreRatio(numerator, denominator) {
   return Math.min(5, Math.max(1, Math.round(numerator / denominator * 5)));
 }
 function readJsonIfExists(path) {
-  if (!existsSync6(path)) return null;
+  if (!existsSync7(path)) return null;
   try {
-    return JSON.parse(readFileSync6(path, "utf-8"));
+    return JSON.parse(readFileSync7(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function loadReviewPack(projectRoot) {
   return readJsonIfExists(
-    join6(projectRoot, ".decantr", "context", "review-pack.json")
+    join7(projectRoot, ".decantr", "context", "review-pack.json")
   );
 }
 function loadPackManifest(projectRoot) {
   return readJsonIfExists(
-    join6(projectRoot, ".decantr", "context", "pack-manifest.json")
+    join7(projectRoot, ".decantr", "context", "pack-manifest.json")
   );
 }
 function collectPackManifestReferences(packManifest) {
@@ -4648,14 +5085,14 @@ function collectPackManifestReferences(packManifest) {
 }
 function collectMissingPackManifestFiles(projectRoot, packManifest = loadPackManifest(projectRoot)) {
   if (!packManifest) return [];
-  const contextDir = join6(projectRoot, ".decantr", "context");
+  const contextDir = join7(projectRoot, ".decantr", "context");
   const missing = [];
   for (const reference of collectPackManifestReferences(packManifest)) {
     for (const field of ["markdown", "json"]) {
       const fileName = reference[field];
       if (!fileName) continue;
-      const absolutePath = join6(contextDir, fileName);
-      if (existsSync6(absolutePath)) continue;
+      const absolutePath = join7(contextDir, fileName);
+      if (existsSync7(absolutePath)) continue;
       missing.push({
         entryId: reference.entryId,
         kind: reference.kind,
@@ -4669,13 +5106,13 @@ function collectMissingPackManifestFiles(projectRoot, packManifest = loadPackMan
 }
 function readTextIfExists(path) {
   try {
-    return existsSync6(path) ? readFileSync6(path, "utf-8") : "";
+    return existsSync7(path) ? readFileSync7(path, "utf-8") : "";
   } catch {
     return "";
   }
 }
 function readProjectAdoptionMode(projectRoot) {
-  const projectJson = readJsonIfExists(join6(projectRoot, ".decantr", "project.json"));
+  const projectJson = readJsonIfExists(join7(projectRoot, ".decantr", "project.json"));
   const adoptionMode = projectJson?.initialized?.adoptionMode;
   return typeof adoptionMode === "string" ? adoptionMode : null;
 }
@@ -4761,7 +5198,7 @@ function collectProjectSourceFiles(projectRoot) {
     "hooks",
     "providers",
     "server"
-  ].map((dir) => join6(projectRoot, dir)).filter((dir) => existsSync6(dir));
+  ].map((dir) => join7(projectRoot, dir)).filter((dir) => existsSync7(dir));
   const rootFileCandidates = [
     "middleware.ts",
     "middleware.tsx",
@@ -4775,7 +5212,7 @@ function collectProjectSourceFiles(projectRoot) {
     "proxy.jsx",
     "proxy.mts",
     "proxy.cts"
-  ].map((file) => join6(projectRoot, file)).filter((file) => existsSync6(file));
+  ].map((file) => join7(projectRoot, file)).filter((file) => existsSync7(file));
   const files = /* @__PURE__ */ new Set();
   const ignoredDirNames = /* @__PURE__ */ new Set([
     "node_modules",
@@ -4786,9 +5223,9 @@ function collectProjectSourceFiles(projectRoot) {
     "coverage"
   ]);
   const walk = (dir) => {
-    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join6(dir, entry.name);
+      const absolutePath = join7(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
         continue;
@@ -4819,7 +5256,7 @@ function isAuditableStyleFile(filePath) {
   return /\.css$/i.test(filePath);
 }
 function collectProjectStyleFiles2(projectRoot) {
-  const candidates = ["src", "app", "styles"].map((dir) => join6(projectRoot, dir)).filter((dir) => existsSync6(dir));
+  const candidates = ["src", "app", "styles"].map((dir) => join7(projectRoot, dir)).filter((dir) => existsSync7(dir));
   const files = /* @__PURE__ */ new Set();
   const ignoredDirNames = /* @__PURE__ */ new Set([
     "node_modules",
@@ -4830,9 +5267,9 @@ function collectProjectStyleFiles2(projectRoot) {
     "coverage"
   ]);
   const walk = (dir) => {
-    for (const entry of readdirSync5(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(dir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join6(dir, entry.name);
+      const absolutePath = join7(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
         continue;
@@ -4906,9 +5343,9 @@ function collectRuntimeImportSpecifiers(entry) {
 function resolveSourceImportTarget(projectRoot, sourceAbsolutePath, specifier) {
   let basePath = null;
   if (specifier.startsWith("@/")) {
-    basePath = join6(projectRoot, "src", specifier.slice(2));
+    basePath = join7(projectRoot, "src", specifier.slice(2));
   } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    basePath = resolve3(dirname2(sourceAbsolutePath), specifier);
+    basePath = resolve4(dirname3(sourceAbsolutePath), specifier);
   }
   if (!basePath) return null;
   const candidates = [
@@ -4919,14 +5356,14 @@ function resolveSourceImportTarget(projectRoot, sourceAbsolutePath, specifier) {
     `${basePath}.jsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join6(basePath, "index.ts"),
-    join6(basePath, "index.tsx"),
-    join6(basePath, "index.js"),
-    join6(basePath, "index.jsx")
+    join7(basePath, "index.ts"),
+    join7(basePath, "index.tsx"),
+    join7(basePath, "index.js"),
+    join7(basePath, "index.jsx")
   ];
   for (const candidate of candidates) {
-    if (existsSync6(candidate) && isAuditableSourceFile(candidate)) {
-      return relative6(projectRoot, candidate) || candidate;
+    if (existsSync7(candidate) && isAuditableSourceFile(candidate)) {
+      return relative7(projectRoot, candidate) || candidate;
     }
   }
   return null;
@@ -4974,8 +5411,8 @@ function isClientAuthHeaderSource(relativePath, code, clientReachableFiles) {
 function auditProjectSourceTree(projectRoot, sourceFiles = collectProjectSourceFiles(projectRoot)) {
   const sourceEntries = sourceFiles.map((sourceFile) => ({
     absolutePath: sourceFile,
-    relativePath: relative6(projectRoot, sourceFile) || sourceFile,
-    code: readFileSync6(sourceFile, "utf-8")
+    relativePath: relative7(projectRoot, sourceFile) || sourceFile,
+    code: readFileSync7(sourceFile, "utf-8")
   })).filter((entry) => !isNonProductionSourceAuditFile(entry.relativePath));
   const clientReachableFiles = collectClientReachableSourceFiles(projectRoot, sourceEntries);
   const summary = {
@@ -5288,8 +5725,8 @@ function auditProjectStyleContracts(projectRoot) {
     reducedMotionSignals: createSourceAuditBucket()
   };
   for (const styleFile of styleFiles) {
-    const relativePath = relative6(projectRoot, styleFile) || styleFile;
-    const css = readFileSync6(styleFile, "utf-8");
+    const relativePath = relative7(projectRoot, styleFile) || styleFile;
+    const css = readFileSync7(styleFile, "utf-8");
     recordSourceAudit(summary.focusVisibleSignals, relativePath, countFocusVisibleSignals(css));
     recordSourceAudit(summary.reducedMotionSignals, relativePath, countReducedMotionSignals(css));
   }
@@ -5298,19 +5735,19 @@ function auditProjectStyleContracts(projectRoot) {
 function buildRegistryContext(projectRoot) {
   const themeRegistry = /* @__PURE__ */ new Map();
   const patternRegistry = /* @__PURE__ */ new Map();
-  const cacheDir = join6(projectRoot, ".decantr", "cache");
-  const customDir = join6(projectRoot, ".decantr", "custom");
+  const cacheDir = join7(projectRoot, ".decantr", "cache");
+  const customDir = join7(projectRoot, ".decantr", "custom");
   const addPattern = (id, source, data = null) => {
     if (typeof id !== "string" || !id.trim() || patternRegistry.has(id)) return;
     patternRegistry.set(id, data ?? { id, source });
   };
-  const cachedThemesDir = join6(cacheDir, "@official", "themes");
+  const cachedThemesDir = join7(cacheDir, "@official", "themes");
   try {
-    if (existsSync6(cachedThemesDir)) {
-      for (const file of readdirSync5(cachedThemesDir).filter(
+    if (existsSync7(cachedThemesDir)) {
+      for (const file of readdirSync6(cachedThemesDir).filter(
         (name) => name.endsWith(".json") && name !== "index.json"
       )) {
-        const data = JSON.parse(readFileSync6(join6(cachedThemesDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync7(join7(cachedThemesDir, file), "utf-8"));
         if (data.id && !themeRegistry.has(data.id)) {
           themeRegistry.set(data.id, { modes: data.modes || ["light", "dark"] });
         }
@@ -5318,11 +5755,11 @@ function buildRegistryContext(projectRoot) {
     }
   } catch {
   }
-  const customThemesDir = join6(customDir, "themes");
+  const customThemesDir = join7(customDir, "themes");
   try {
-    if (existsSync6(customThemesDir)) {
-      for (const file of readdirSync5(customThemesDir).filter((name) => name.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync6(join6(customThemesDir, file), "utf-8"));
+    if (existsSync7(customThemesDir)) {
+      for (const file of readdirSync6(customThemesDir).filter((name) => name.endsWith(".json"))) {
+        const data = JSON.parse(readFileSync7(join7(customThemesDir, file), "utf-8"));
         if (data.id) {
           themeRegistry.set(`custom:${data.id}`, { modes: data.modes || ["light", "dark"] });
         }
@@ -5330,29 +5767,29 @@ function buildRegistryContext(projectRoot) {
     }
   } catch {
   }
-  const cachedPatternsDir = join6(cacheDir, "@official", "patterns");
+  const cachedPatternsDir = join7(cacheDir, "@official", "patterns");
   try {
-    if (existsSync6(cachedPatternsDir)) {
-      for (const file of readdirSync5(cachedPatternsDir).filter(
+    if (existsSync7(cachedPatternsDir)) {
+      for (const file of readdirSync6(cachedPatternsDir).filter(
         (name) => name.endsWith(".json") && name !== "index.json"
       )) {
-        const data = JSON.parse(readFileSync6(join6(cachedPatternsDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync7(join7(cachedPatternsDir, file), "utf-8"));
         addPattern(data.id, "cache", data);
       }
     }
   } catch {
   }
-  const customPatternsDir = join6(customDir, "patterns");
+  const customPatternsDir = join7(customDir, "patterns");
   try {
-    if (existsSync6(customPatternsDir)) {
-      for (const file of readdirSync5(customPatternsDir).filter((name) => name.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync6(join6(customPatternsDir, file), "utf-8"));
+    if (existsSync7(customPatternsDir)) {
+      for (const file of readdirSync6(customPatternsDir).filter((name) => name.endsWith(".json"))) {
+        const data = JSON.parse(readFileSync7(join7(customPatternsDir, file), "utf-8"));
         addPattern(data.id, "custom", data);
       }
     }
   } catch {
   }
-  const localPatterns = readJsonIfExists(join6(projectRoot, ".decantr", "local-patterns.json"));
+  const localPatterns = readJsonIfExists(join7(projectRoot, ".decantr", "local-patterns.json"));
   for (const pattern of localPatterns?.patterns ?? []) {
     addPattern(pattern.id, "local-law", pattern);
   }
@@ -5650,7 +6087,8 @@ function appendTopologyFindings(findings, essence, reviewPack) {
 }
 async function runRuntimeAudit(projectRoot, essence) {
   return auditBuiltDist(projectRoot, {
-    routeHints: extractRouteHintsFromEssence(essence)
+    routeHints: extractRouteHintsFromEssence(essence),
+    runtimeTarget: typeof essence?.meta?.target === "string" ? essence.meta.target : null
   });
 }
 function extractFailedRouteDocuments(runtimeAudit) {
@@ -5660,8 +6098,8 @@ function extractFailedRouteDocumentHardening(runtimeAudit) {
   return runtimeAudit.failures.filter((failure) => failure.startsWith("route-document-hardening-failed:")).map((failure) => normalizeRouteHint2(failure.slice("route-document-hardening-failed:".length))).filter(Boolean);
 }
 function appendRuntimeAuditFindings(findings, runtimeAudit, projectRoot, topology, sourceAudit) {
-  const distPath = join6(projectRoot, "dist");
-  const indexPath = join6(distPath, "index.html");
+  const distPath = join7(projectRoot, "dist");
+  const indexPath = join7(distPath, "index.html");
   const isFrameworkBuildOutput = runtimeAudit.failures.includes("next-build-output");
   if (!runtimeAudit.distPresent) {
     findings.push(
@@ -6206,7 +6644,7 @@ function appendRuntimeAuditFindings(findings, runtimeAudit, projectRoot, topolog
 }
 function readBehaviorPatterns(projectRoot) {
   const pack = readJsonIfExists(
-    join6(projectRoot, ".decantr", "local-patterns.json")
+    join7(projectRoot, ".decantr", "local-patterns.json")
   );
   return (pack?.patterns ?? []).filter(
     (pattern) => pattern.behavior_obligations && Array.isArray(pattern.behavior_obligations.obligations) && pattern.behavior_obligations.obligations.length > 0
@@ -6253,15 +6691,15 @@ function isFormPrimitiveDefinitionFile(pattern, relativeFile) {
   );
 }
 function sourceAuditFilePath(projectRoot, file) {
-  return isAbsolute4(file) ? file : join6(projectRoot, file);
+  return isAbsolute4(file) ? file : join7(projectRoot, file);
 }
 function sourceAuditRelativePath(projectRoot, file) {
-  return (isAbsolute4(file) ? relative6(projectRoot, file) : file).replace(/\\/g, "/");
+  return (isAbsolute4(file) ? relative7(projectRoot, file) : file).replace(/\\/g, "/");
 }
 function sourceFileContainsAny(projectRoot, sourceFiles, patterns) {
   for (const file of sourceFiles.slice(0, 400)) {
     try {
-      const code = readFileSync6(sourceAuditFilePath(projectRoot, file), "utf-8");
+      const code = readFileSync7(sourceAuditFilePath(projectRoot, file), "utf-8");
       if (patterns.some((pattern) => pattern.test(code))) return true;
     } catch {
     }
@@ -6315,7 +6753,7 @@ function appendBehaviorObligationFindings(findings, projectRoot, sourceFiles) {
       const relativeFile = sourceAuditRelativePath(projectRoot, file);
       let code = "";
       try {
-        code = readFileSync6(sourceAuditFilePath(projectRoot, file), "utf-8");
+        code = readFileSync7(sourceAuditFilePath(projectRoot, file), "utf-8");
       } catch {
         continue;
       }
@@ -6392,7 +6830,7 @@ function appendBehaviorObligationFindings(findings, projectRoot, sourceFiles) {
     const relativeFile = sourceAuditRelativePath(projectRoot, file);
     let code = "";
     try {
-      code = readFileSync6(sourceAuditFilePath(projectRoot, file), "utf-8");
+      code = readFileSync7(sourceAuditFilePath(projectRoot, file), "utf-8");
     } catch {
       continue;
     }
@@ -7759,7 +8197,7 @@ function appendStyleContractFindings(findings, styleAudit, essence) {
   }
 }
 async function auditProject(projectRoot) {
-  const essencePath = join6(projectRoot, "decantr.essence.json");
+  const essencePath = join7(projectRoot, "decantr.essence.json");
   const findings = [];
   const reviewPack = loadReviewPack(projectRoot);
   const packManifest = loadPackManifest(projectRoot);
@@ -7767,7 +8205,7 @@ async function auditProject(projectRoot) {
   const packHydrationOptional = adoptionMode === "contract-only" || adoptionMode === "style-bridge";
   const packHydrationSeverity = packHydrationOptional ? "info" : "warn";
   const runtimeAudit = emptyRuntimeAudit();
-  if (!existsSync6(essencePath)) {
+  if (!existsSync7(essencePath)) {
     findings.push(
       makeFinding({
         id: "essence-missing",
@@ -7802,7 +8240,7 @@ async function auditProject(projectRoot) {
   }
   let essence = null;
   try {
-    essence = JSON.parse(readFileSync6(essencePath, "utf-8"));
+    essence = JSON.parse(readFileSync7(essencePath, "utf-8"));
   } catch (error) {
     findings.push(
       makeFinding({
@@ -7845,7 +8283,7 @@ async function auditProject(projectRoot) {
         category: "Execution Packs",
         severity: packHydrationSeverity,
         message: packHydrationOptional ? "Compiled execution pack manifest is not hydrated yet; this is optional for contract-only/style-bridge Brownfield adoption." : "Compiled execution pack manifest is missing.",
-        evidence: [join6(projectRoot, ".decantr", "context", "pack-manifest.json")],
+        evidence: [join7(projectRoot, ".decantr", "context", "pack-manifest.json")],
         suggestedFix: packHydrationOptional ? "Optional: run `decantr registry compile-packs decantr.essence.json --write-context` when you want hosted page packs and review packs for richer assistant context." : "Run `decantr registry compile-packs decantr.essence.json --write-context` to hydrate scaffold, review, mutation, section, and page packs."
       })
     );
@@ -7909,7 +8347,7 @@ async function auditProject(projectRoot) {
         category: "Review Contract",
         severity: packHydrationSeverity,
         message: packHydrationOptional ? "The compiled review pack file is not hydrated yet; contract-only/style-bridge Brownfield projects can continue without it." : "The compiled review pack file is missing.",
-        evidence: [join6(projectRoot, ".decantr", "context", "review-pack.json")],
+        evidence: [join7(projectRoot, ".decantr", "context", "review-pack.json")],
         suggestedFix: packHydrationOptional ? "Optional: hydrate hosted packs later if you want critique consumers to anchor findings to the compiled review contract." : "Hydrate the full hosted context bundle with `decantr registry compile-packs decantr.essence.json --write-context` so critique consumers can anchor findings to the compiled review contract."
       })
     );
@@ -8056,7 +8494,7 @@ function countKeyboardShortcutSignals(code) {
   return matches.length;
 }
 function getScriptKind(filePath) {
-  switch (extname6(filePath).toLowerCase()) {
+  switch (extname7(filePath).toLowerCase()) {
     case ".tsx":
       return ts6.ScriptKind.TSX;
     case ".jsx":
@@ -16112,10 +16550,10 @@ function critiqueSource({
   };
 }
 function resolveProjectFilePath(projectRoot, filePath) {
-  const root = existsSync6(projectRoot) ? realpathSync2.native(projectRoot) : resolve3(projectRoot);
-  const candidatePath = isAbsolute4(filePath) ? resolve3(filePath) : resolve3(root, filePath);
-  const resolvedPath = existsSync6(candidatePath) ? realpathSync2.native(candidatePath) : candidatePath;
-  const relativePath = relative6(root, resolvedPath);
+  const root = existsSync7(projectRoot) ? realpathSync2.native(projectRoot) : resolve4(projectRoot);
+  const candidatePath = isAbsolute4(filePath) ? resolve4(filePath) : resolve4(root, filePath);
+  const resolvedPath = existsSync7(candidatePath) ? realpathSync2.native(candidatePath) : candidatePath;
+  const relativePath = relative7(root, resolvedPath);
   if (relativePath.startsWith("..") || isAbsolute4(relativePath)) {
     throw new Error(`Path escapes the project root: ${filePath}`);
   }
@@ -16124,7 +16562,7 @@ function resolveProjectFilePath(projectRoot, filePath) {
 async function critiqueFile(filePath, projectRoot) {
   const resolvedPath = resolveProjectFilePath(projectRoot, filePath);
   const code = await readFile(resolvedPath, "utf-8");
-  const treatmentsCss = readTextIfExists(join6(projectRoot, "src", "styles", "treatments.css"));
+  const treatmentsCss = readTextIfExists(join7(projectRoot, "src", "styles", "treatments.css"));
   const reviewPack = loadReviewPack(projectRoot);
   const packManifest = loadPackManifest(projectRoot);
   const adoptionMode = readProjectAdoptionMode(projectRoot);
@@ -16151,6 +16589,8 @@ export {
   RAW_CONTROL_REUSE_RULE_ID,
   RUNTIME_PROBE_PAYLOAD_V2_SCHEMA_URL,
   SCAN_REPORT_SCHEMA_URL,
+  SCAN_REPORT_V1_SCHEMA_URL,
+  SCAN_REPORT_V2_SCHEMA_URL,
   STYLE_BRIDGE_ARBITRARY_VALUE_RULE_ID,
   VERIFICATION_COMMON_V2_SCHEMA_URL,
   VERIFICATION_SCHEMA_URLS,
@@ -16176,6 +16616,7 @@ export {
   critiqueFile,
   critiqueSource,
   deriveVerificationDiagnostic,
+  discoverProject,
   emptyRuntimeAudit,
   extractRouteHintsFromEssence,
   extractSourceStringLiterals,