@decantr/cli 1.7.27 → 1.7.29

package/dist/chunk-DI2PLOJ6.js

@@ -0,0 +1,1418 @@
+// src/lib/scan-interactions.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { extname, join } from "path";
+import { verifyInteractionsInSource } from "@decantr/verifier";
+var SCAN_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".ts", ".js", ".html", ".mdx"]);
+var SKIP_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".decantr",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  "coverage",
+  ".cache"
+]);
+var MAX_FILE_SIZE = 1024 * 1024;
+function walkSourceTree(rootDir) {
+  const sources = /* @__PURE__ */ new Map();
+  function walk2(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIP_DIRECTORIES.has(entry)) continue;
+      const fullPath = join(dir, entry);
+      let s;
+      try {
+        s = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (s.isDirectory()) {
+        walk2(fullPath);
+      } else if (s.isFile() && SCAN_EXTENSIONS.has(extname(entry))) {
+        if (s.size > MAX_FILE_SIZE) continue;
+        try {
+          sources.set(fullPath, readFileSync(fullPath, "utf8"));
+        } catch {
+        }
+      }
+    }
+  }
+  walk2(rootDir);
+  return sources;
+}
+function collectDeclaredInteractions(projectRoot) {
+  const manifestPath = join(projectRoot, ".decantr", "context", "pack-manifest.json");
+  if (!existsSync(manifestPath)) return [];
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch {
+    return [];
+  }
+  const all = [];
+  const pages = manifest.pages ?? [];
+  const contextDir = join(projectRoot, ".decantr", "context");
+  for (const page of pages) {
+    const packPath = join(contextDir, page.json);
+    if (!existsSync(packPath)) continue;
+    let pack;
+    try {
+      pack = JSON.parse(readFileSync(packPath, "utf8"));
+    } catch {
+      continue;
+    }
+    const patterns = pack.data?.patterns ?? [];
+    for (const pat of patterns) {
+      if (Array.isArray(pat.interactions)) {
+        all.push(...pat.interactions);
+      }
+    }
+  }
+  return all;
+}
+function scanProjectInteractions(projectRoot) {
+  const declared = collectDeclaredInteractions(projectRoot);
+  if (declared.length === 0) return [];
+  const sources = walkSourceTree(projectRoot);
+  if (sources.size === 0) return [];
+  const missing = verifyInteractionsInSource(declared, sources);
+  return missing.map(({ interaction, suggestion }) => `${interaction} \u2192 ${suggestion}`);
+}
+
+// src/guard-context.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function loadJsonEntries(dir) {
+  if (!existsSync2(dir)) return [];
+  try {
+    return readdirSync2(dir).filter((file) => file.endsWith(".json") && file !== "index.json").map((file) => JSON.parse(readFileSync2(join2(dir, file), "utf-8")));
+  } catch {
+    return [];
+  }
+}
+function buildGuardRegistryContext(projectRoot = process.cwd()) {
+  const themeRegistry = /* @__PURE__ */ new Map();
+  const patternRegistry = /* @__PURE__ */ new Map();
+  const cacheDir = join2(projectRoot, ".decantr", "cache");
+  const customDir = join2(projectRoot, ".decantr", "custom");
+  for (const data of loadJsonEntries(join2(cacheDir, "@official", "themes"))) {
+    if (typeof data.id === "string" && !themeRegistry.has(data.id)) {
+      themeRegistry.set(data.id, {
+        modes: Array.isArray(data.modes) ? data.modes.filter((mode) => typeof mode === "string") : ["light", "dark"]
+      });
+    }
+  }
+  for (const data of loadJsonEntries(join2(customDir, "themes"))) {
+    if (typeof data.id === "string") {
+      themeRegistry.set(`custom:${data.id}`, {
+        modes: Array.isArray(data.modes) ? data.modes.filter((mode) => typeof mode === "string") : ["light", "dark"]
+      });
+    }
+  }
+  for (const data of loadJsonEntries(join2(cacheDir, "@official", "patterns"))) {
+    if (typeof data.id === "string" && !patternRegistry.has(data.id)) {
+      patternRegistry.set(data.id, data);
+    }
+  }
+  for (const data of loadJsonEntries(join2(customDir, "patterns"))) {
+    if (typeof data.id === "string") {
+      patternRegistry.set(data.id, data);
+    }
+  }
+  return { themeRegistry, patternRegistry };
+}
+
+// src/telemetry.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+import {
+  createFetchTelemetrySink,
+  createTelemetryClient,
+  isTelemetryActorType
+} from "@decantr/telemetry";
+var TELEMETRY_ENDPOINT = "https://api.decantr.ai/v1/telemetry/guard";
+var DEFAULT_TELEMETRY_EVENTS_ENDPOINT = "https://api.decantr.ai/v1/telemetry/events";
+var TELEMETRY_TIMEOUT_MS = 3e3;
+var DNA_RULES = /* @__PURE__ */ new Set(["theme", "style", "density", "accessibility", "theme-mode"]);
+async function sendGuardMetrics(metrics) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
+    await fetch(TELEMETRY_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(metrics),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+  } catch {
+  }
+}
+function isOptedIn(projectRoot) {
+  const projectJsonPath = join3(projectRoot, ".decantr", "project.json");
+  if (!existsSync3(projectJsonPath)) return false;
+  try {
+    const data = JSON.parse(readFileSync3(projectJsonPath, "utf-8"));
+    return data.telemetry === true;
+  } catch {
+    return false;
+  }
+}
+function optIn(projectRoot) {
+  const projectJsonPath = join3(projectRoot, ".decantr", "project.json");
+  let data = {};
+  if (existsSync3(projectJsonPath)) {
+    try {
+      data = JSON.parse(readFileSync3(projectJsonPath, "utf-8"));
+    } catch {
+    }
+  }
+  data.telemetry = true;
+  mkdirSync(dirname(projectJsonPath), { recursive: true });
+  writeFileSync(projectJsonPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+async function sendCliCommandTelemetry(input) {
+  const projectRoot = input.projectRoot ?? process.cwd();
+  const command = normalizeCommand(input.args[0]);
+  if (!isOptedIn(projectRoot) || !command || command === "help" || command === "version") {
+    return;
+  }
+  const identities = ensureTelemetryIdentities(projectRoot);
+  if (!identities) {
+    return;
+  }
+  const client = createTelemetryClient({
+    sink: createFetchTelemetrySink({
+      endpoint: getTelemetryEventsEndpoint(),
+      timeoutMs: TELEMETRY_TIMEOUT_MS
+    })
+  });
+  const event = {
+    name: "cli.command.completed",
+    context: {
+      source: "cli",
+      actorType: getTelemetryActorType(),
+      environment: "production",
+      decantrVersion: getCliVersion(),
+      installId: identities.installId,
+      projectId: identities.projectId,
+      registrySource: inferRegistrySource(input.args)
+    },
+    properties: {
+      command,
+      success: input.success,
+      durationMs: input.durationMs,
+      adoptionMode: inferAdoptionMode(input.args),
+      errorCode: input.success ? void 0 : "cli_command_failed",
+      offline: input.args.includes("--offline"),
+      projectScope: inferProjectScope(projectRoot),
+      registrySource: inferRegistrySource(input.args),
+      targetFramework: inferFlagValue(input.args, "--target"),
+      workflowMode: inferWorkflowMode(input.args)
+    }
+  };
+  try {
+    await client.capture(event);
+  } catch {
+  }
+}
+function collectMetrics(essence, issues) {
+  const dna = essence.dna ?? {};
+  const blueprint = essence.blueprint ?? {};
+  const meta = essence.meta ?? {};
+  const guard = meta.guard ?? {};
+  const theme = dna.theme ?? {};
+  const sections = blueprint.sections ?? [];
+  const routes = blueprint.routes ?? {};
+  const byRule = {};
+  let dnaCount = 0;
+  let blueprintCount = 0;
+  for (const issue of issues) {
+    byRule[issue.rule] = (byRule[issue.rule] ?? 0) + 1;
+    if (DNA_RULES.has(issue.rule)) {
+      dnaCount++;
+    } else {
+      blueprintCount++;
+    }
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    cli_version: getCliVersion(),
+    essence_version: essence.version ?? "unknown",
+    guard_mode: guard.mode ?? "unknown",
+    violations: {
+      dna: dnaCount,
+      blueprint: blueprintCount,
+      by_rule: byRule
+    },
+    resolution_rate: 0,
+    sections_count: sections.length,
+    routes_count: Object.keys(routes).length,
+    theme: theme.id ?? "unknown"
+  };
+}
+function ensureTelemetryIdentities(projectRoot) {
+  const installId = getOrCreateInstallId();
+  const projectJsonPath = join3(projectRoot, ".decantr", "project.json");
+  if (!existsSync3(projectJsonPath)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(readFileSync3(projectJsonPath, "utf-8"));
+    let projectId = typeof data.telemetryProjectId === "string" ? data.telemetryProjectId : void 0;
+    if (!projectId) {
+      projectId = `project_${randomUUID()}`;
+      data.telemetryProjectId = projectId;
+      writeFileSync(projectJsonPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    }
+    return { installId, projectId };
+  } catch {
+    return null;
+  }
+}
+function getOrCreateInstallId() {
+  const configDir = getConfigDir();
+  const configPath = join3(configDir, "config.json");
+  try {
+    if (existsSync3(configPath)) {
+      const data = JSON.parse(readFileSync3(configPath, "utf-8"));
+      if (typeof data.telemetryInstallId === "string") {
+        return data.telemetryInstallId;
+      }
+      const installId2 = `install_${randomUUID()}`;
+      data.telemetryInstallId = installId2;
+      writeFileSync(configPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+      return installId2;
+    }
+    mkdirSync(configDir, { recursive: true });
+    const installId = `install_${randomUUID()}`;
+    writeFileSync(
+      configPath,
+      JSON.stringify({ telemetryInstallId: installId }, null, 2) + "\n",
+      "utf-8"
+    );
+    return installId;
+  } catch {
+    return `install_${randomUUID()}`;
+  }
+}
+function getConfigDir() {
+  return process.env.DECANTR_CONFIG_DIR || join3(homedir(), ".config", "decantr");
+}
+function getTelemetryEventsEndpoint() {
+  return process.env.DECANTR_TELEMETRY_ENDPOINT || DEFAULT_TELEMETRY_EVENTS_ENDPOINT;
+}
+function getTelemetryActorType() {
+  const configured = process.env.DECANTR_TELEMETRY_ACTOR_TYPE;
+  return isTelemetryActorType(configured) ? configured : "customer";
+}
+function normalizeCommand(command) {
+  if (!command) return null;
+  if (command === "--help" || command === "-h") return "help";
+  if (command === "--version" || command === "-v") return "version";
+  return command;
+}
+function inferFlagValue(args, flag) {
+  const equalsPrefix = `${flag}=`;
+  const inline = args.find((arg) => arg.startsWith(equalsPrefix));
+  if (inline) {
+    return inline.slice(equalsPrefix.length) || void 0;
+  }
+  const index = args.indexOf(flag);
+  if (index !== -1 && args[index + 1] && !args[index + 1].startsWith("-")) {
+    return args[index + 1];
+  }
+  return void 0;
+}
+function inferAdoptionMode(args) {
+  const value = inferFlagValue(args, "--adoption");
+  if (value === "contract-only" || value === "decantr-css" || value === "style-bridge") {
+    return value;
+  }
+  return void 0;
+}
+function inferWorkflowMode(args) {
+  const value = inferFlagValue(args, "--workflow");
+  if (value === "greenfield" || value === "greenfield-scaffold") {
+    return "greenfield-scaffold";
+  }
+  if (value === "contract" || value === "greenfield-contract-only") {
+    return "greenfield-contract-only";
+  }
+  if (value === "brownfield" || value === "brownfield-attach") {
+    return "brownfield-attach";
+  }
+  if (value === "hybrid" || value === "hybrid-compose") {
+    return "hybrid-compose";
+  }
+  return void 0;
+}
+function inferRegistrySource(args) {
+  if (args.includes("--offline")) {
+    return "cache";
+  }
+  if (args.some((arg) => arg === "--registry" || arg.startsWith("--registry="))) {
+    return "custom";
+  }
+  return "official";
+}
+function inferProjectScope(projectRoot) {
+  return existsSync3(join3(projectRoot, "pnpm-workspace.yaml")) || existsSync3(join3(projectRoot, "turbo.json")) || existsSync3(join3(projectRoot, "lerna.json")) ? "workspace-app" : "single-app";
+}
+function getCliVersion() {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [join3(here, "..", "package.json"), join3(here, "..", "..", "package.json")];
+    for (const candidate of candidates) {
+      if (existsSync3(candidate)) {
+        const pkg = JSON.parse(readFileSync3(candidate, "utf-8"));
+        if (pkg.version) {
+          return pkg.version;
+        }
+      }
+    }
+  } catch {
+  }
+  return "unknown";
+}
+
+// src/analyzers/routes.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join4, relative } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "api", "_app", "_document"]);
+function shouldSkipDir(name) {
+  return name.startsWith("_") || name.startsWith(".") || SKIP_DIRS.has(name);
+}
+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 walkAppDir(dir, baseDir, segments) {
+  const routes = [];
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch {
+    return routes;
+  }
+  const hasPage = entries.some(
+    (e) => e === "page.tsx" || e === "page.ts" || e === "page.jsx" || e === "page.js"
+  );
+  const hasLayout = entries.some(
+    (e) => e === "layout.tsx" || e === "layout.ts" || e === "layout.jsx" || e === "layout.js"
+  );
+  if (hasPage) {
+    const routePath = "/" + segments.filter((s) => s !== "").join("/");
+    const pageFile = entries.find((e) => e.startsWith("page."));
+    routes.push({
+      path: routePath || "/",
+      file: relative(baseDir, join4(dir, pageFile)),
+      hasLayout
+    });
+  }
+  for (const entry of entries) {
+    if (shouldSkipDir(entry)) continue;
+    const fullPath = join4(dir, entry);
+    try {
+      if (!statSync2(fullPath).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const routeSegment = segmentToRoute(entry);
+    const nextSegments = routeSegment === null ? [...segments] : [...segments, routeSegment];
+    routes.push(...walkAppDir(fullPath, baseDir, nextSegments));
+  }
+  return routes;
+}
+function walkPagesDir(dir, baseDir, segments, extensions = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "md", "mdx"])) {
+  const routes = [];
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch {
+    return routes;
+  }
+  for (const entry of entries) {
+    if (shouldSkipDir(entry)) continue;
+    const fullPath = join4(dir, entry);
+    try {
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        const routeSegment = segmentToRoute(entry);
+        const nextSegments = routeSegment === null ? [...segments] : [...segments, routeSegment];
+        routes.push(...walkPagesDir(fullPath, baseDir, nextSegments, extensions));
+      } else if (stat.isFile()) {
+        const match = entry.match(/^(.+)\.([^.]+)$/);
+        if (!match) continue;
+        const name = match[1];
+        const extension = match[2];
+        if (!extensions.has(extension)) continue;
+        if (name.startsWith("_")) continue;
+        const routeSegment = name === "index" ? "" : segmentToRoute(name) ?? name;
+        const routePath = "/" + [...segments, routeSegment].filter((s) => s !== "").join("/");
+        routes.push({
+          path: routePath || "/",
+          file: relative(baseDir, fullPath),
+          hasLayout: false
+        });
+      }
+    } catch {
+    }
+  }
+  return routes;
+}
+function walkSvelteKitRoutes(dir, baseDir, segments) {
+  const routes = [];
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch {
+    return routes;
+  }
+  const pageFile = entries.find((entry) => /^\+page\.(svelte|ts|js)$/.test(entry));
+  const hasLayout = entries.some((entry) => /^\+layout\.(svelte|ts|js)$/.test(entry));
+  if (pageFile) {
+    const routePath = "/" + segments.filter((segment) => segment !== "").join("/");
+    routes.push({
+      path: routePath || "/",
+      file: relative(baseDir, join4(dir, pageFile)),
+      hasLayout
+    });
+  }
+  for (const entry of entries) {
+    if (shouldSkipDir(entry)) continue;
+    const fullPath = join4(dir, entry);
+    try {
+      if (!statSync2(fullPath).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const routeSegment = segmentToRoute(entry);
+    const nextSegments = routeSegment === null ? [...segments] : [...segments, routeSegment];
+    routes.push(...walkSvelteKitRoutes(fullPath, baseDir, nextSegments));
+  }
+  return routes;
+}
+var ROUTER_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".ts", ".jsx", ".js"]);
+function collectRouteCandidateFiles(dir, files, depth = 0) {
+  if (depth > 5) return;
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.startsWith(".") || entry === "node_modules") continue;
+    const fullPath = join4(dir, entry);
+    try {
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        collectRouteCandidateFiles(fullPath, files, depth + 1);
+      } else if (stat.isFile()) {
+        const ext = entry.slice(entry.lastIndexOf("."));
+        if (ROUTER_FILE_EXTENSIONS.has(ext)) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function scanReactRouter(projectRoot) {
+  const candidateDirs = [join4(projectRoot, "src"), projectRoot];
+  const candidateFiles = [];
+  for (const dir of candidateDirs) {
+    if (existsSync4(dir)) collectRouteCandidateFiles(dir, candidateFiles);
+  }
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const absolutePath of candidateFiles) {
+    let content;
+    try {
+      content = readFileSync4(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    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 (!isReactRouterFile) continue;
+    const relativePath = relative(projectRoot, absolutePath);
+    const pathMatches = /* @__PURE__ */ new Set();
+    for (const match of content.matchAll(/<Route\b[^>]*\bpath=["'`]([^"'`]+)["'`]/g)) {
+      pathMatches.add(match[1]);
+    }
+    for (const match of content.matchAll(/\bpath\s*:\s*["'`]([^"'`]+)["'`]/g)) {
+      pathMatches.add(match[1]);
+    }
+    if (pathMatches.size === 0 && (content.includes("<Routes") || content.includes("RouterProvider"))) {
+      pathMatches.add("/");
+    }
+    for (const path of pathMatches) {
+      if (!routeMap.has(path)) {
+        routeMap.set(path, {
+          path,
+          file: relativePath,
+          hasLayout: false
+        });
+      }
+    }
+  }
+  return [...routeMap.values()];
+}
+function hasReactRouterDependency(projectRoot) {
+  return hasDependency(projectRoot, ["react-router", "react-router-dom"]);
+}
+function hasDependency(projectRoot, names) {
+  const packageJsonPath = join4(projectRoot, "package.json");
+  if (!existsSync4(packageJsonPath)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return names.some((name) => Boolean(deps[name]));
+  } catch {
+    return false;
+  }
+}
+function hasAnyFile(projectRoot, relPaths) {
+  return relPaths.some((relPath) => existsSync4(join4(projectRoot, relPath)));
+}
+function normalizeRoutePath(path) {
+  const cleaned = path.trim();
+  if (!cleaned || cleaned === "/") return "/";
+  if (cleaned === "**" || cleaned.startsWith("#")) return null;
+  return cleaned.startsWith("/") ? cleaned : `/${cleaned}`;
+}
+function scanAngularRouter(projectRoot) {
+  const candidateDirs = [join4(projectRoot, "src", "app"), join4(projectRoot, "src")];
+  const candidateFiles = [];
+  for (const dir of candidateDirs) {
+    if (existsSync4(dir)) collectRouteCandidateFiles(dir, candidateFiles);
+  }
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const absolutePath of candidateFiles) {
+    let content;
+    try {
+      content = readFileSync4(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const isRouterFile = content.includes("@angular/router") || content.includes("RouterModule.forRoot") || content.includes("provideRouter") || content.includes("Routes =");
+    if (!isRouterFile) continue;
+    const relativePath = relative(projectRoot, absolutePath);
+    for (const match of content.matchAll(/\bpath\s*:\s*["'`]([^"'`]*)["'`]/g)) {
+      const routePath = normalizeRoutePath(match[1]);
+      if (!routePath || routeMap.has(routePath)) continue;
+      routeMap.set(routePath, {
+        path: routePath,
+        file: relativePath,
+        hasLayout: false
+      });
+    }
+  }
+  return [...routeMap.values()];
+}
+function scanVueRouter(projectRoot) {
+  const candidateDirs = [join4(projectRoot, "src"), projectRoot];
+  const candidateFiles = [];
+  for (const dir of candidateDirs) {
+    if (existsSync4(dir)) collectRouteCandidateFiles(dir, candidateFiles);
+  }
+  const routeMap = /* @__PURE__ */ new Map();
+  for (const absolutePath of candidateFiles) {
+    let content;
+    try {
+      content = readFileSync4(absolutePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const isRouterFile = content.includes("vue-router") || content.includes("createRouter") || content.includes("createWebHistory") || content.includes("createWebHashHistory");
+    if (!isRouterFile) continue;
+    const relativePath = relative(projectRoot, absolutePath);
+    for (const match of content.matchAll(/\bpath\s*:\s*["'`]([^"'`]+)["'`]/g)) {
+      const routePath = normalizeRoutePath(match[1]);
+      if (!routePath || routeMap.has(routePath)) continue;
+      routeMap.set(routePath, {
+        path: routePath,
+        file: relativePath,
+        hasLayout: false
+      });
+    }
+  }
+  return [...routeMap.values()];
+}
+function scanRoutes(projectRoot) {
+  const hasNext = hasDependency(projectRoot, ["next"]) || hasAnyFile(projectRoot, ["next.config.js", "next.config.ts", "next.config.mjs"]);
+  const hasSvelteKit = hasDependency(projectRoot, ["@sveltejs/kit", "svelte"]) || hasAnyFile(projectRoot, ["svelte.config.js", "svelte.config.ts"]);
+  const hasNuxt = hasDependency(projectRoot, ["nuxt"]) || hasAnyFile(projectRoot, ["nuxt.config.js", "nuxt.config.ts"]);
+  const hasAngular = hasDependency(projectRoot, ["@angular/core", "@angular/router"]) || hasAnyFile(projectRoot, ["angular.json"]);
+  const hasVue = hasDependency(projectRoot, ["vue", "vue-router"]) || hasAnyFile(projectRoot, ["vite.config.js", "vite.config.ts"]);
+  const appDirs = [join4(projectRoot, "src", "app"), join4(projectRoot, "app")];
+  const appRoutes = appDirs.flatMap(
+    (appDir) => existsSync4(appDir) ? walkAppDir(appDir, projectRoot, []) : []
+  );
+  const pagesDirs = [join4(projectRoot, "src", "pages"), join4(projectRoot, "pages")];
+  const pagesRoutes = pagesDirs.flatMap(
+    (pagesDir) => existsSync4(pagesDir) ? walkPagesDir(pagesDir, projectRoot, []) : []
+  );
+  if (hasNext) {
+    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 };
+  } else if (appRoutes.length > 0) {
+    return { strategy: "app-router", routes: appRoutes };
+  }
+  if (hasSvelteKit) {
+    const svelteRoutesDir = join4(projectRoot, "src", "routes");
+    if (existsSync4(svelteRoutesDir)) {
+      const routes = walkSvelteKitRoutes(svelteRoutesDir, projectRoot, []);
+      if (routes.length > 0) return { strategy: "sveltekit-router", routes };
+    }
+  }
+  if (hasNuxt) {
+    const nuxtPagesDirs = [join4(projectRoot, "pages"), join4(projectRoot, "app", "pages")];
+    const routes = nuxtPagesDirs.flatMap(
+      (pagesDir) => existsSync4(pagesDir) ? walkPagesDir(pagesDir, projectRoot, [], /* @__PURE__ */ new Set(["vue"])) : []
+    );
+    if (routes.length > 0) return { strategy: "nuxt-router", routes };
+  }
+  const reactRouterRoutes = scanReactRouter(projectRoot);
+  if (reactRouterRoutes.length > 0 && hasReactRouterDependency(projectRoot)) {
+    return { strategy: "react-router", routes: reactRouterRoutes };
+  }
+  if (hasAngular) {
+    const routes = scanAngularRouter(projectRoot);
+    if (routes.length > 0) return { strategy: "angular-router", routes };
+  }
+  if (hasVue) {
+    const routes = scanVueRouter(projectRoot);
+    if (routes.length > 0) return { strategy: "vue-router", routes };
+  }
+  if (pagesRoutes.length > 0) {
+    return { strategy: "pages-router", routes: pagesRoutes };
+  }
+  if (reactRouterRoutes.length > 0) {
+    return { strategy: "react-router", routes: reactRouterRoutes };
+  }
+  return { strategy: "none", routes: [] };
+}
+
+// src/analyzers/styling.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+var TAILWIND_CONFIGS = [
+  "tailwind.config.js",
+  "tailwind.config.ts",
+  "tailwind.config.mjs",
+  "tailwind.config.cjs"
+];
+var GLOBALS_CSS_PATHS = [
+  "src/app/globals.css",
+  "app/globals.css",
+  "src/styles/global.css",
+  "src/styles/globals.css",
+  "src/styles/main.css",
+  "src/styles.css",
+  "styles/globals.css",
+  "styles.css",
+  "assets/css/main.css",
+  "src/index.css",
+  "src/app.css",
+  "src/global.css"
+];
+var DECANTR_STYLE_PATHS = [
+  "src/styles/tokens.css",
+  "src/styles/treatments.css",
+  "src/styles/global.css"
+];
+function extractCSSVariables(content) {
+  const colors = {};
+  const variables = [];
+  const varRegex = /--([\w-]+)\s*:\s*([^;]+)/g;
+  let match;
+  while ((match = varRegex.exec(content)) !== null) {
+    const name = match[1];
+    const value = match[2].trim();
+    variables.push(`--${name}`);
+    const colorPatterns = [
+      "primary",
+      "secondary",
+      "accent",
+      "bg",
+      "fg",
+      "border",
+      "success",
+      "warning",
+      "error",
+      "surface",
+      "muted"
+    ];
+    if (value.startsWith("#") || value.startsWith("rgb") || value.startsWith("hsl") || colorPatterns.some((p) => name.includes(p))) {
+      colors[name] = value;
+    }
+  }
+  return { colors, variables };
+}
+function detectDarkMode(projectRoot, cssContents) {
+  for (const cssContent of cssContents) {
+    if (cssContent.includes(".dark") || cssContent.includes('[data-theme="dark"]') || cssContent.includes("prefers-color-scheme: dark") || cssContent.includes("color-scheme: dark")) {
+      return true;
+    }
+  }
+  const layoutPaths = [
+    "src/app/layout.tsx",
+    "app/layout.tsx",
+    "src/app/layout.jsx",
+    "app/layout.jsx"
+  ];
+  for (const rel of layoutPaths) {
+    const fullPath = join5(projectRoot, rel);
+    if (existsSync5(fullPath)) {
+      try {
+        const layoutContent = readFileSync5(fullPath, "utf-8");
+        if (layoutContent.includes('className="dark"') || layoutContent.includes("className='dark'") || layoutContent.includes('class="dark"')) {
+          return true;
+        }
+      } catch {
+      }
+    }
+  }
+  const pkgPath = join5(projectRoot, "package.json");
+  if (existsSync5(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps["next-themes"] || allDeps["theme-toggle"] || allDeps["use-dark-mode"]) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  const essencePath = join5(projectRoot, "decantr.essence.json");
+  if (existsSync5(essencePath)) {
+    try {
+      const essence = JSON.parse(readFileSync5(essencePath, "utf-8"));
+      const mode = essence.dna?.theme?.mode;
+      if (mode === "dark" || mode === "auto") {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function scanStyling(projectRoot) {
+  let approach = "unknown";
+  let configFile;
+  let packageDeps = {};
+  const pkgPath = join5(projectRoot, "package.json");
+  if (existsSync5(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      packageDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    } catch {
+      packageDeps = {};
+    }
+  }
+  for (const cfg of TAILWIND_CONFIGS) {
+    if (existsSync5(join5(projectRoot, cfg))) {
+      approach = "tailwind";
+      configFile = cfg;
+      break;
+    }
+  }
+  if (approach === "unknown") {
+    if (packageDeps["@decantr/css"]) {
+      approach = "decantr-css";
+      configFile = "src/styles/tokens.css";
+    }
+    if (packageDeps.tailwindcss || packageDeps["@tailwindcss/postcss"] || packageDeps["@tailwindcss/vite"]) {
+      approach = "tailwind";
+      configFile = configFile ?? "package.json";
+    }
+  }
+  if (approach === "unknown") {
+    if (packageDeps.bootstrap || packageDeps["react-bootstrap"]) {
+      approach = "bootstrap";
+      configFile = "package.json";
+    } else if (packageDeps["@mui/material"] || packageDeps["@mui/system"] || packageDeps["@mui/joy"]) {
+      approach = "mui";
+      configFile = "package.json";
+    } else if (packageDeps["@chakra-ui/react"] || packageDeps["@chakra-ui/vue-next"] || packageDeps["@chakra-ui/system"]) {
+      approach = "chakra";
+      configFile = "package.json";
+    }
+  }
+  const decantrStyleFiles = DECANTR_STYLE_PATHS.filter((rel) => existsSync5(join5(projectRoot, rel)));
+  if (decantrStyleFiles.length >= 2) {
+    approach = "decantr-css";
+    configFile = decantrStyleFiles.join(" + ");
+  }
+  const cssContents = [];
+  for (const rel of GLOBALS_CSS_PATHS) {
+    const fullPath = join5(projectRoot, rel);
+    if (existsSync5(fullPath)) {
+      try {
+        cssContents.push(readFileSync5(fullPath, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  for (const rel of DECANTR_STYLE_PATHS) {
+    if (GLOBALS_CSS_PATHS.includes(rel)) continue;
+    const fullPath = join5(projectRoot, rel);
+    if (existsSync5(fullPath)) {
+      try {
+        cssContents.push(readFileSync5(fullPath, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  let colors = {};
+  let cssVariables = [];
+  for (const cssContent of cssContents) {
+    const extracted = extractCSSVariables(cssContent);
+    colors = { ...colors, ...extracted.colors };
+    cssVariables.push(...extracted.variables);
+  }
+  cssVariables = [...new Set(cssVariables)];
+  const darkMode = detectDarkMode(projectRoot, cssContents);
+  if (approach === "unknown" && cssContents.length > 0) {
+    approach = "css";
+    configFile = GLOBALS_CSS_PATHS.find((rel) => existsSync5(join5(projectRoot, rel)));
+  }
+  return {
+    approach,
+    configFile,
+    colors,
+    darkMode,
+    cssVariables
+  };
+}
+
+// src/ambient-context.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { basename, extname as extname2, join as join6, relative as relative2, sep as sep2 } from "path";
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  ".decantr",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".vercel",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "playwright-report"
+]);
+var ROOT_CONTEXT_FILES = /* @__PURE__ */ new Set([
+  "AGENTS.md",
+  "CLAUDE.md",
+  "GEMINI.md",
+  "README.md",
+  "copilot-instructions.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".cursorignore",
+  ".claudeignore",
+  "components.json",
+  "tailwind.config.js",
+  "tailwind.config.ts",
+  "tailwind.config.mjs",
+  "tailwind.config.cjs",
+  "next.config.js",
+  "next.config.ts",
+  "next.config.mjs",
+  "nuxt.config.js",
+  "nuxt.config.ts",
+  "astro.config.mjs",
+  "astro.config.ts",
+  "svelte.config.js",
+  "svelte.config.ts",
+  "angular.json",
+  "vite.config.js",
+  "vite.config.ts",
+  "vitest.config.ts",
+  "vitest.config.js",
+  "playwright.config.ts",
+  "playwright.config.js",
+  "tsconfig.json",
+  "package.json",
+  "decantr.essence.json"
+]);
+var CONTEXT_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".agents",
+  ".claude",
+  ".claude/initiatives",
+  ".claude/rules",
+  ".codex",
+  ".cursor",
+  ".cursor/rules",
+  ".github/workflows",
+  "docs",
+  "docs/initiatives",
+  "initiatives",
+  "memory",
+  "memories",
+  "project-memory",
+  "supabase"
+]);
+function shouldSkipDir2(name) {
+  return SKIP_DIRS2.has(name);
+}
+function normalizedPath(relPath) {
+  return relPath.split(sep2).join("/");
+}
+function isPotentialContextFile(relPath, name) {
+  const normalized2 = normalizedPath(relPath);
+  if (ROOT_CONTEXT_FILES.has(name)) return true;
+  if (name.startsWith(".env")) return true;
+  if (normalized2.startsWith(".claude/")) return true;
+  if (normalized2.startsWith(".agents/")) return true;
+  if (normalized2.startsWith(".codex/")) return true;
+  if (normalized2.startsWith(".cursor/")) return true;
+  if (normalized2.startsWith(".github/workflows/")) return true;
+  if (normalized2.startsWith("docs/")) return true;
+  if (normalized2.startsWith("initiatives/")) return true;
+  if (normalized2.startsWith("memory/")) return true;
+  if (normalized2.startsWith("memories/")) return true;
+  if (normalized2.startsWith("project-memory/")) return true;
+  if (normalized2.startsWith("supabase/")) return true;
+  if (normalized2.startsWith("migrations/")) return true;
+  if (normalized2.startsWith("db/")) return true;
+  if (normalized2.startsWith("ROLEMIGRATIONS/")) return true;
+  if (normalized2 === "src/middleware.ts" || normalized2 === "middleware.ts") return true;
+  if (normalized2.includes("/middleware.")) return true;
+  const ext = extname2(name).toLowerCase();
+  return ext === ".md" || ext === ".mdx" || ext === ".sql" || ext === ".yml" || ext === ".yaml";
+}
+function classifyContext(relPath) {
+  const normalized2 = normalizedPath(relPath);
+  const lower = normalized2.toLowerCase();
+  const name = basename(normalized2);
+  if (lower === "decantr.essence.json") {
+    return {
+      role: "architecture",
+      confidence: 0.82,
+      reason: "existing Decantr contract evidence"
+    };
+  }
+  if (lower === ".claude/initiatives" || lower === "docs/initiatives" || lower === "initiatives" || lower === "memory" || lower === "memories" || lower === "project-memory" || lower.startsWith(".claude/initiatives/") || lower.startsWith("docs/initiatives/") || lower.startsWith("initiatives/") || lower.startsWith("memory/") || lower.startsWith("memories/") || lower.startsWith("project-memory/") || lower.includes("/feature/") || lower.includes("feature") || lower.includes("rbac") || lower.includes("billing") || lower.includes("admin") || lower.includes("dashboard")) {
+    return {
+      role: "feature-business",
+      confidence: 0.78,
+      reason: "feature, initiative, memory, or business-domain evidence"
+    };
+  }
+  if (lower === ".agents" || lower === ".claude" || lower === ".codex" || lower === ".cursor" || lower === "claude.md" || lower === "agents.md" || lower === "gemini.md" || lower === "copilot-instructions.md" || lower === ".cursorrules" || lower === ".windsurfrules" || lower.startsWith(".claude/") || lower.startsWith(".agents/") || lower.startsWith(".codex/") || lower.startsWith(".cursor/rules/")) {
+    return {
+      role: "assistant-specific",
+      confidence: 0.98,
+      reason: "assistant or AI-agent instruction surface"
+    };
+  }
+  if (lower.includes("security") || lower.includes("auth") || lower.includes("rls") || lower.includes("schema") || lower.includes("migration") || lower.startsWith("supabase/") || lower.startsWith("migrations/") || lower.startsWith("db/") || lower.startsWith("rolemigrations/") || lower.includes("middleware.")) {
+    return {
+      role: "security-data",
+      confidence: 0.9,
+      reason: "security, auth, schema, middleware, or data-governance evidence"
+    };
+  }
+  if (lower.includes("design-system") || lower === "components.json" || lower.startsWith("tailwind.config") || lower.includes("ui-components") || lower.includes("colors") || lower.includes("typography") || lower.includes("spacing")) {
+    return {
+      role: "design-system",
+      confidence: 0.88,
+      reason: "design system or styling convention evidence"
+    };
+  }
+  if (lower.startsWith(".github/workflows/") || lower.includes("workflow") || lower.includes("testing") || lower.includes("deployment") || lower.includes("vitest.config") || lower.includes("playwright.config") || lower === "package.json") {
+    return {
+      role: "workflow-ci",
+      confidence: 0.84,
+      reason: "workflow, CI, deployment, or validation command evidence"
+    };
+  }
+  if (lower === "docs" || lower.includes("architecture") || lower === "readme.md" || lower.includes("setup") || lower.includes("contributing") || name === "tsconfig.json" || lower.endsWith("config.ts") || lower.endsWith("config.js") || lower.endsWith("config.mjs")) {
+    return {
+      role: "architecture",
+      confidence: 0.72,
+      reason: "architecture, setup, or framework configuration evidence"
+    };
+  }
+  if (lower.includes("complete") || lower.includes("summary") || lower.includes("deprecated") || lower.includes("legacy") || lower.includes("migration")) {
+    return {
+      role: "stale-or-historical",
+      confidence: 0.64,
+      reason: "historical or possibly stale project documentation"
+    };
+  }
+  return { role: "unknown", confidence: 0.35, reason: "unclassified context candidate" };
+}
+function isSafeToCite(relPath) {
+  const lower = normalizedPath(relPath).toLowerCase();
+  if (lower.startsWith(".env") && lower !== ".env.example" && lower !== ".env.sample") return false;
+  if (lower.includes("secret") || lower.includes("private-key") || lower.includes("credentials")) {
+    return false;
+  }
+  return true;
+}
+function addDirectoryContext(items, projectRoot, relPath) {
+  const fullPath = join6(projectRoot, relPath);
+  if (!existsSync6(fullPath)) return;
+  const stats = statSync3(fullPath);
+  const classified = classifyContext(relPath);
+  items.push({
+    path: normalizedPath(relPath),
+    type: "directory",
+    role: classified.role,
+    confidence: classified.confidence,
+    sizeBytes: stats.size,
+    safeToCite: isSafeToCite(relPath),
+    reason: classified.reason
+  });
+}
+function walk(projectRoot, dir, items, depth) {
+  if (depth > 6) return;
+  let entries;
+  try {
+    entries = readdirSync4(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (shouldSkipDir2(entry)) continue;
+    const fullPath = join6(dir, entry);
+    const relPath = normalizedPath(relative2(projectRoot, fullPath));
+    let stats;
+    try {
+      stats = statSync3(fullPath);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      if (CONTEXT_DIRECTORIES.has(relPath)) {
+        addDirectoryContext(items, projectRoot, relPath);
+      }
+      walk(projectRoot, fullPath, items, depth + 1);
+      continue;
+    }
+    if (!stats.isFile() || !isPotentialContextFile(relPath, entry)) continue;
+    const classified = classifyContext(relPath);
+    items.push({
+      path: relPath,
+      type: "file",
+      role: classified.role,
+      confidence: classified.confidence,
+      sizeBytes: stats.size,
+      safeToCite: isSafeToCite(relPath),
+      reason: classified.reason
+    });
+  }
+}
+function summarize(items) {
+  const summary = {
+    "assistant-specific": 0,
+    "security-data": 0,
+    architecture: 0,
+    "design-system": 0,
+    "workflow-ci": 0,
+    "feature-business": 0,
+    "stale-or-historical": 0,
+    unknown: 0
+  };
+  for (const item of items) summary[item.role] += 1;
+  return summary;
+}
+function readSmallText(projectRoot, relPath) {
+  const fullPath = join6(projectRoot, relPath);
+  try {
+    const stat = statSync3(fullPath);
+    if (stat.size > 64e3) return "";
+    return readFileSync6(fullPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function detectConflicts(projectRoot, items) {
+  const text = items.filter((item) => item.type === "file" && item.safeToCite && item.path.match(/\.(md|mdx|json|ts|js|yml|yaml)$/)).slice(0, 80).map((item) => readSmallText(projectRoot, item.path)).join("\n").toLowerCase();
+  const conflicts = [];
+  const frameworkSignals = [
+    ["next", /\bnext\.?js\b|\bapp router\b|\bpages router\b/],
+    ["angular", /\bangular\b/],
+    ["svelte", /\bsvelte\b|\bsveltekit\b/],
+    ["vue", /\bvue\b|\bnuxt\b/]
+  ].filter(([, pattern]) => pattern.test(text));
+  if (frameworkSignals.length > 1) {
+    conflicts.push(
+      `Multiple framework doctrines appear in ambient docs: ${frameworkSignals.map(([name]) => name).join(", ")}.`
+    );
+  }
+  const forbidsTailwind = /\b(do not|don't|avoid|forbid|forbidden)\s+use\s+tailwind\b|\bno\s+tailwind\b/.test(text);
+  const endorsesTailwind = /\btailwind\.config\b|\btailwindcss\b|\b@tailwind\b|\btailwind\s+classes\b/.test(
+    text
+  );
+  if (forbidsTailwind && endorsesTailwind) {
+    conflicts.push("Ambient docs contain both Tailwind usage and anti-Tailwind language.");
+  }
+  if (/\bclient component\b/.test(text) && /\bserver components? only\b/.test(text)) {
+    conflicts.push("Ambient docs may conflict on client vs server component boundaries.");
+  }
+  return conflicts;
+}
+function detectDecantrEssenceStaleRisk(projectRoot, items) {
+  if (!items.some((item) => item.path === "decantr.essence.json")) return [];
+  const content = readSmallText(projectRoot, "decantr.essence.json");
+  if (!content) return [];
+  try {
+    const essence = JSON.parse(content);
+    const risks = [];
+    if (essence.version !== "3.1.0") {
+      risks.push(
+        `decantr.essence.json uses Decantr essence version ${essence.version ?? "unknown"}; migrate or review before treating it as current brownfield doctrine.`
+      );
+    }
+    if (essence.dna?.theme?.id === "luminarum" && essence.structure) {
+      risks.push(
+        "decantr.essence.json looks like an older Decantr default scaffold; verify before importing its theme or page layout as brownfield truth."
+      );
+    }
+    return risks;
+  } catch {
+    return [
+      "decantr.essence.json could not be parsed during ambient inventory; review before treating it as current doctrine."
+    ];
+  }
+}
+function detectStaleRisks(projectRoot, items) {
+  const pathRisks = items.filter(
+    (item) => item.role === "stale-or-historical" || /complete|summary|legacy|deprecated/i.test(item.path)
+  ).slice(0, 12).map((item) => `${item.path} may be historical; verify before treating it as current doctrine.`);
+  return [...pathRisks, ...detectDecantrEssenceStaleRisk(projectRoot, items)];
+}
+function scanAmbientContext(projectRoot) {
+  const items = [];
+  walk(projectRoot, projectRoot, items, 0);
+  const deduped = [...new Map(items.map((item) => [item.path, item])).values()].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  return {
+    version: 1,
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    items: deduped,
+    summary: summarize(deduped),
+    conflicts: detectConflicts(projectRoot, deduped),
+    staleRisks: detectStaleRisks(projectRoot, deduped)
+  };
+}
+
+// src/doctrine-map.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
+var PRECEDENCE_ORDER = [
+  "security-data",
+  "architecture",
+  "design-system",
+  "workflow-ci",
+  "feature-business",
+  "assistant-specific",
+  "stale-or-historical",
+  "unknown"
+];
+var BASE_PRECEDENCE = {
+  "security-data": 100,
+  architecture: 88,
+  "design-system": 82,
+  "workflow-ci": 74,
+  "feature-business": 66,
+  "assistant-specific": 58,
+  "stale-or-historical": 24,
+  unknown: 12
+};
+function normalized(path) {
+  return path.toLowerCase();
+}
+function isStalePath(path, staleRisks) {
+  const lower = normalized(path);
+  if (/complete|summary|legacy|deprecated/.test(lower)) return true;
+  return staleRisks.some((risk) => risk.toLowerCase().startsWith(lower));
+}
+function inferArea(item) {
+  const lower = normalized(item.path);
+  if (lower.includes("security") || lower.includes("auth") || lower.includes("rls") || lower.includes("schema") || lower.includes("database") || lower.includes("data-layer") || lower.includes("middleware") || lower.startsWith("supabase/") || lower.startsWith("migrations/") || lower.startsWith("rolemigrations/")) {
+    return "security-data";
+  }
+  if (lower.includes("design-system") || lower.includes("ui-components") || lower.includes("colors") || lower.includes("typography") || lower.includes("spacing") || lower.includes("components.json") || lower.includes("tailwind.config")) {
+    return "design-system";
+  }
+  if (lower.includes("architecture") || lower.includes("state-management") || lower.includes("setup") || lower.includes("readme") || lower.endsWith("config.ts") || lower.endsWith("config.js") || lower.endsWith("config.mjs")) {
+    return "architecture";
+  }
+  if (lower.includes("workflow") || lower.includes("deployment") || lower.includes("quality") || lower.includes("testing") || lower.includes("vitest") || lower.includes("playwright") || lower.startsWith(".github/workflows/")) {
+    return "workflow-ci";
+  }
+  return item.role;
+}
+function precedenceFor(item, area, staleRisks) {
+  let score = BASE_PRECEDENCE[area];
+  const lower = normalized(item.path);
+  if (lower.startsWith(".claude/rules/") || lower.startsWith(".cursor/rules/")) score += 6;
+  if (lower === "claude.md" || lower === "agents.md" || lower === "copilot-instructions.md") {
+    score += 3;
+  }
+  if (item.type === "directory") score -= 8;
+  if (isStalePath(item.path, staleRisks)) score -= 35;
+  if (!item.safeToCite) score -= 20;
+  return Math.max(0, Math.min(100, score));
+}
+function summarize2(sources) {
+  const summary = Object.fromEntries(PRECEDENCE_ORDER.map((area) => [area, 0]));
+  for (const source of sources) summary[source.area] += 1;
+  return summary;
+}
+function topSources(sources, areas, limit = 5) {
+  return sources.filter((source) => source.currency === "current" && areas.includes(source.area)).slice(0, limit).map((source) => source.path);
+}
+function buildResolutions(conflicts, staleRisks, sources) {
+  const resolutions = [];
+  for (const conflict of conflicts) {
+    const lower = conflict.toLowerCase();
+    if (lower.includes("framework")) {
+      resolutions.push({
+        kind: "conflict",
+        issue: conflict,
+        recommendation: "Prefer package/config detection and current architecture sources over stale docs or assistant memory when deciding framework/runtime conventions.",
+        preferredSources: topSources(sources, ["architecture", "workflow-ci"]),
+        confidence: 0.78
+      });
+      continue;
+    }
+    if (lower.includes("tailwind")) {
+      resolutions.push({
+        kind: "conflict",
+        issue: conflict,
+        recommendation: "Preserve the existing styling system until the user approves migration; treat current design-system docs and Tailwind/shadcn config as the styling authority.",
+        preferredSources: topSources(sources, ["design-system", "architecture"]),
+        confidence: 0.82
+      });
+      continue;
+    }
+    if (lower.includes("client") && lower.includes("server")) {
+      resolutions.push({
+        kind: "conflict",
+        issue: conflict,
+        recommendation: "Prefer current framework architecture and security/data boundaries; stop and ask for review before moving client/server responsibilities.",
+        preferredSources: topSources(sources, ["architecture", "security-data"]),
+        confidence: 0.76
+      });
+      continue;
+    }
+    resolutions.push({
+      kind: "conflict",
+      issue: conflict,
+      recommendation: "Use the highest-precedence current sources in the doctrine map and report the conflict before enforcing either side.",
+      preferredSources: sources.filter((source) => source.currency === "current").slice(0, 5).map((source) => source.path),
+      confidence: 0.62
+    });
+  }
+  if (staleRisks.length > 0) {
+    resolutions.push({
+      kind: "stale-risk",
+      issue: `${staleRisks.length} stale or historical source(s) detected.`,
+      recommendation: "Treat stale-risk sources as historical evidence until confirmed by current security/data, architecture, design-system, workflow, or feature doctrine.",
+      preferredSources: sources.filter((source) => source.currency === "current" && source.area !== "assistant-specific").slice(0, 5).map((source) => source.path),
+      confidence: 0.84
+    });
+  }
+  return resolutions;
+}
+function createDoctrineMap(ambient) {
+  const sources = ambient.items.map((item) => {
+    const area = inferArea(item);
+    const stale = isStalePath(item.path, ambient.staleRisks);
+    return {
+      path: item.path,
+      type: item.type,
+      area: stale ? "stale-or-historical" : area,
+      originalRole: item.role,
+      precedence: precedenceFor(item, area, ambient.staleRisks),
+      confidence: item.confidence,
+      currency: !item.safeToCite ? "unsafe-to-cite" : stale ? "stale-risk" : "current",
+      safeToCite: item.safeToCite,
+      rationale: item.reason
+    };
+  }).sort((a, b) => b.precedence - a.precedence || a.path.localeCompare(b.path));
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    precedenceOrder: PRECEDENCE_ORDER,
+    sources,
+    summary: summarize2(sources),
+    conflicts: ambient.conflicts,
+    staleRisks: ambient.staleRisks,
+    resolutions: buildResolutions(ambient.conflicts, ambient.staleRisks, sources),
+    guidance: [
+      "Treat security/data doctrine as highest precedence for implementation safety.",
+      "Treat architecture and design-system sources as product conventions, not Decantr defaults.",
+      "Treat workflow/CI sources as validation evidence for commands and release gates.",
+      "Treat stale-risk sources as historical evidence until a current source confirms them.",
+      "Do not cite unsafe sources directly in assistant context."
+    ]
+  };
+}
+function doctrineMapPath(projectRoot) {
+  return join7(projectRoot, ".decantr", "doctrine-map.json");
+}
+function writeDoctrineMap(projectRoot, doctrine) {
+  writeFileSync2(doctrineMapPath(projectRoot), JSON.stringify(doctrine, null, 2) + "\n", "utf-8");
+}
+function readDoctrineMap(projectRoot) {
+  const path = doctrineMapPath(projectRoot);
+  if (!existsSync7(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+    if (parsed.version !== 1 || !Array.isArray(parsed.sources)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  scanProjectInteractions,
+  scanRoutes,
+  scanStyling,
+  scanAmbientContext,
+  createDoctrineMap,
+  writeDoctrineMap,
+  readDoctrineMap,
+  buildGuardRegistryContext,
+  sendGuardMetrics,
+  isOptedIn,
+  optIn,
+  sendCliCommandTelemetry,
+  collectMetrics
+};