@archpilotlabs/archpilot 0.2.1 → 0.2.2

package/dist/archpilot-cli.js

@@ -140818,9 +140818,9 @@ ${lanes.join("\n")}
             /*ignoreCase*/
             false
           )) {
-            const basename8 = getBaseFileName(a.fileName);
-            if (basename8 === "lib.d.ts" || basename8 === "lib.es6.d.ts") return 0;
-            const name = removeSuffix(removePrefix(basename8, "lib."), ".d.ts");
+            const basename9 = getBaseFileName(a.fileName);
+            if (basename9 === "lib.d.ts" || basename9 === "lib.es6.d.ts") return 0;
+            const name = removeSuffix(removePrefix(basename9, "lib."), ".d.ts");
             const index = libs.indexOf(name);
             if (index !== -1) return index + 1;
           }
@@ -204566,8 +204566,8 @@ ${options.prefix}` : "\n" : options.prefix
             }
           };
           for (const file of files) {
-            const basename8 = getBaseFileName(file);
-            if (basename8 === "package.json" || basename8 === "bower.json") {
+            const basename9 = getBaseFileName(file);
+            if (basename9 === "package.json" || basename9 === "bower.json") {
               createProjectWatcher(
                 file,
                 "FileWatcher"
@@ -208239,8 +208239,8 @@ All files are: ${JSON.stringify(names)}`,
               var _a;
               const fileOrDirectoryPath = removeIgnoredPath(this.toPath(fileOrDirectory));
               if (!fileOrDirectoryPath) return;
-              const basename8 = getBaseFileName(fileOrDirectoryPath);
-              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename8 === "package.json" || basename8 === "node_modules")) {
+              const basename9 = getBaseFileName(fileOrDirectoryPath);
+              if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename9 === "package.json" || basename9 === "node_modules")) {
                 result.affectedModuleSpecifierCacheProjects.forEach((project) => {
                   var _a2;
                   (_a2 = project.getModuleSpecifierCache()) == null ? void 0 : _a2.clear();
@@ -215396,15 +215396,83 @@ var init_architectureDependencyContext = __esm({
   }
 });
 
+// ../core/src/sourceScopeClassification.ts
+function normalizePath3(value) {
+  return value.replace(/\\/g, "/").toLowerCase();
+}
+function hasPathSegment(pathValue, pattern) {
+  return pathValue.split("/").some((segment) => pattern.test(segment));
+}
+function hasTopLevelPathSegment(pathValue, pattern) {
+  const [firstSegment] = pathValue.split("/");
+  return !!firstSegment && pattern.test(firstSegment);
+}
+function classifyValidationSourceScope(relativePath) {
+  const normalized = normalizePath3(relativePath);
+  const fileName = normalized.split("/").at(-1) ?? normalized;
+  const extension = fileName.includes(".") ? fileName.slice(fileName.lastIndexOf(".")) : "";
+  const isTestFile = /\.(?:spec|test|e2e-spec|integration-test)\.(?:ts|tsx|js|jsx|mjs|cjs|java|cs|py|php|go)$/u.test(fileName);
+  const isE2e = isTestFile && /(?:^|[./_-])e2e(?:[./_-]|$)/u.test(fileName) || hasPathSegment(normalized, /^e2e$/u);
+  const isFixture = hasPathSegment(normalized, /^(?:fixtures?|__fixtures__)$/u);
+  const isTestPlugin = hasPathSegment(normalized, /^(?:test-plugins?|testing-plugins?)$/u);
+  const isExamplePlugin = hasPathSegment(normalized, /^example-plugins?$/u) || hasTopLevelPathSegment(normalized, /^examples?$/u);
+  const isGenerated = hasPathSegment(normalized, /^(?:generated|__generated__|gen|templates?)$/u) || /\.(?:generated|gen|g)\.(?:ts|tsx|js|jsx|java|cs|py|php|go)$/u.test(fileName) || /\.d\.ts$/u.test(fileName);
+  const isMigration = hasPathSegment(normalized, /^(?:migrations?|schema-migrations?|data-migrations|migration-utils?)$/u);
+  const isCliTooling = hasPathSegment(normalized, /^(?:cli|bin|scripts?|tools?|scaffold|scaffolding|generators?)$/u) || /(?:^|[./_-])(?:cli|script|tool|generator|scaffold)(?:[./_-]|$)/u.test(fileName);
+  const isFrontend = extension === ".tsx" || extension === ".jsx" || hasPathSegment(normalized, /^(?:frontend|client|browser|ui|admin-ui|dashboard|web-app)$/u) || /\b(?:react|angular|vue|svelte)\b/u.test(normalized);
+  const isInfrastructure = hasPathSegment(normalized, /^(?:infrastructure|infra|framework|adapters?|persistence|providers?)$/u) || /(?:transactional-connection|transaction-wrapper|transaction-subscriber|transaction-manager|query-runner|query-builder|event-bus|telemetry|interceptor)\.(?:ts|js|java|cs|py|php|go)$/u.test(fileName);
+  let category = "production-backend";
+  if (isGenerated) {
+    category = "generated";
+  } else if (isE2e) {
+    category = "e2e";
+  } else if (isTestFile || hasPathSegment(normalized, /^(?:test|tests|__tests__|spec|specs|__mocks__|cypress|cypress-tests)$/u)) {
+    category = "test";
+  } else if (isTestPlugin) {
+    category = "test-plugin";
+  } else if (isExamplePlugin) {
+    category = "example-plugin";
+  } else if (isFixture) {
+    category = "fixture";
+  } else if (isMigration) {
+    category = "migration";
+  } else if (isCliTooling) {
+    category = "cli-tooling";
+  } else if (isFrontend) {
+    category = "production-frontend";
+  } else if (isInfrastructure) {
+    category = "infrastructure";
+  }
+  const isTestLike = category === "test" || category === "e2e" || category === "fixture" || category === "test-plugin" || category === "example-plugin";
+  return {
+    category,
+    isProduction: category === "production-backend" || category === "production-frontend" || category === "infrastructure",
+    isFrontend: category === "production-frontend",
+    isTestLike,
+    isGenerated: category === "generated",
+    isMigration: category === "migration",
+    isCliTooling: category === "cli-tooling",
+    isInfrastructure: category === "infrastructure"
+  };
+}
+function isProductionBackendGovernanceScope(scope) {
+  return scope.category === "production-backend";
+}
+var init_sourceScopeClassification = __esm({
+  "../core/src/sourceScopeClassification.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/dependencyValidation.ts
-function normalizePath3(filePath) {
+function normalizePath4(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function toSafeContractModuleFileStem(moduleName) {
-  return normalizePath3(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
+  return normalizePath4(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
 }
 function normalizeAbsolutePath(filePath) {
-  return normalizePath3(path7.resolve(filePath)).toLowerCase();
+  return normalizePath4(path7.resolve(filePath)).toLowerCase();
 }
 function isPathInsideOrEqual2(childPath, parentPath) {
   const child = normalizeAbsolutePath(childPath);
@@ -215442,7 +215510,7 @@ function getComponentModuleRoots(workspaceRoot, architectureContract) {
     }
     const typed = value;
     const componentId = typeof typed.id === "string" && typed.id.trim().length > 0 ? typed.id.trim() : typeof key === "string" && key.trim().length > 0 ? key.trim() : void 0;
-    const componentPath = typeof typed.path === "string" && typed.path.trim().length > 0 ? normalizePath3(typed.path.trim()) : void 0;
+    const componentPath = typeof typed.path === "string" && typed.path.trim().length > 0 ? normalizePath4(typed.path.trim()) : void 0;
     if (!componentId || !componentPath || componentPath === ".") {
       continue;
     }
@@ -215642,7 +215710,7 @@ async function buildTsConfigPathAliasMap(workspaceRoot, moduleRoots) {
         continue;
       }
       const isWildcard = /\/\*$/u.test(aliasPattern) && /\/\*$/u.test(targetPattern);
-      const normalizedTarget = normalizePath3(targetPattern).replace(/\/\*$/u, "");
+      const normalizedTarget = normalizePath4(targetPattern).replace(/\/\*$/u, "");
       const absoluteTarget = path7.join(workspaceRoot, ...normalizedTarget.split("/"));
       const moduleEntry = [...moduleRoots.entries()].filter(([, moduleRoot2]) => isPathInsideOrEqual2(absoluteTarget, moduleRoot2)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
       if (!moduleEntry) {
@@ -215745,7 +215813,7 @@ async function findModuleRoots(workspaceRoot, modulesRootRelativePath = "src/mod
     if (!configuredPath || typeof configuredPath !== "string") {
       continue;
     }
-    const normalizedConfiguredPath = normalizePath3(configuredPath);
+    const normalizedConfiguredPath = normalizePath4(configuredPath);
     if (/\.[a-z0-9]+$/iu.test(normalizedConfiguredPath)) {
       continue;
     }
@@ -215853,7 +215921,7 @@ async function buildExplicitStandaloneModulePathMap(workspaceRoot, architectureC
     if (!configuredPath || typeof configuredPath !== "string") {
       continue;
     }
-    const normalizedConfiguredPath = normalizePath3(configuredPath);
+    const normalizedConfiguredPath = normalizePath4(configuredPath);
     if (!/\.[a-z0-9]+$/iu.test(normalizedConfiguredPath)) {
       continue;
     }
@@ -215869,11 +215937,7 @@ async function buildExplicitStandaloneModulePathMap(workspaceRoot, architectureC
   return map;
 }
 function isTestSourcePath(relativePath) {
-  const normalized = normalizePath3(relativePath).toLowerCase();
-  if (normalized.includes("/__tests__/") || normalized.includes("/test/") || normalized.includes("/tests/") || normalized.includes("/__mocks__/")) {
-    return true;
-  }
-  return /(^|\/)[^/]+\.(test|spec)\.[cm]?[jt]sx?$/u.test(normalized);
+  return classifyValidationSourceScope(relativePath).isTestLike;
 }
 async function collectSourceFiles(directoryPath, adapter, scanRootPath = directoryPath, excludedDirectoryRoots = []) {
   const entries = await import_node_fs6.promises.readdir(directoryPath, { withFileTypes: true });
@@ -215887,7 +215951,7 @@ async function collectSourceFiles(directoryPath, adapter, scanRootPath = directo
       )) {
         continue;
       }
-      const normalizedRelativeDirectory = normalizePath3(
+      const normalizedRelativeDirectory = normalizePath4(
         path7.relative(scanRootPath, fullPath)
       );
       if (adapter.ignoreDirectoryNames.includes(entry.name) || adapter.ignoreDirectoryNames.includes(normalizedRelativeDirectory)) {
@@ -216098,6 +216162,80 @@ function extractGoImportSpecifiers(sourceText) {
     return left.specifier.localeCompare(right.specifier);
   });
 }
+function extractJavaPackageName(sourceText) {
+  const match = /^\s*package\s+([a-zA-Z_][\w.]*)\s*;/mu.exec(sourceText);
+  return match?.[1];
+}
+async function buildJavaImportIndex(workspaceRoot, moduleRoots, adapter) {
+  const classes = /* @__PURE__ */ new Map();
+  const packageCandidates = /* @__PURE__ */ new Map();
+  for (const [moduleId, moduleRoot] of [...moduleRoots.entries()].sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleId && isPathInsideOrEqual2(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
+    const sourceFiles = await collectSourceFiles(moduleRoot, adapter, moduleRoot, childModuleRoots);
+    for (const sourceFilePath of sourceFiles) {
+      const relativePath = normalizePath4(path7.relative(workspaceRoot, sourceFilePath));
+      if (isTestSourcePath(relativePath)) {
+        continue;
+      }
+      const sourceText = await readTextFileIfExists2(sourceFilePath);
+      if (!sourceText) {
+        continue;
+      }
+      const packageName = extractJavaPackageName(sourceText);
+      if (!packageName) {
+        continue;
+      }
+      const className = path7.basename(sourceFilePath, path7.extname(sourceFilePath));
+      const entry = { moduleId, resolvedPath: sourceFilePath };
+      classes.set(`${packageName}.${className}`, entry);
+      const existing = packageCandidates.get(packageName) ?? [];
+      existing.push(entry);
+      packageCandidates.set(packageName, existing);
+    }
+  }
+  const packages = /* @__PURE__ */ new Map();
+  for (const [packageName, entries] of packageCandidates) {
+    const moduleIds = new Set(entries.map((entry) => entry.moduleId));
+    packages.set(packageName, moduleIds.size === 1 ? entries[0] : "ambiguous");
+  }
+  return { classes, packages };
+}
+function resolveJavaImportFromIndex(importSpecifier, index, workspaceRoot) {
+  if (!index) {
+    return void 0;
+  }
+  if (importSpecifier.endsWith(".*")) {
+    const packageName = importSpecifier.slice(0, -2);
+    const entry = index.packages.get(packageName);
+    if (!entry || entry === "ambiguous") {
+      return void 0;
+    }
+    return {
+      targetModule: entry.moduleId,
+      resolvedRelativePath: normalizePath4(path7.relative(workspaceRoot, entry.resolvedPath)),
+      isPublicImport: false
+    };
+  }
+  const exactEntry = index.classes.get(importSpecifier);
+  if (exactEntry) {
+    return {
+      targetModule: exactEntry.moduleId,
+      resolvedRelativePath: normalizePath4(path7.relative(workspaceRoot, exactEntry.resolvedPath)),
+      isPublicImport: false
+    };
+  }
+  const ownerCandidate = [...index.classes.entries()].filter(([classImport]) => importSpecifier.startsWith(`${classImport}.`)).sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]))[0];
+  if (!ownerCandidate) {
+    return void 0;
+  }
+  return {
+    targetModule: ownerCandidate[1].moduleId,
+    resolvedRelativePath: normalizePath4(path7.relative(workspaceRoot, ownerCandidate[1].resolvedPath)),
+    isPublicImport: false
+  };
+}
 function extractPythonImportSpecifiers(sourceText) {
   const imports = [];
   const lines = sourceText.split(/\r?\n/u);
@@ -216200,7 +216338,7 @@ function resolveJavaModuleImport(modulesRootRelativePath, moduleRoots, importSpe
   const lastSegment = segments[segments.length - 1];
   const defaultEntrypointFileName = adapter.scaffoldingDefaults?.moduleIndexFileName ?? "Application.java";
   const resolvedFileName = lastSegment === "*" ? defaultEntrypointFileName : lastSegment.endsWith(".java") ? lastSegment : `${lastSegment}.java`;
-  const resolvedRelativePath = normalizePath3(
+  const resolvedRelativePath = normalizePath4(
     `${modulesRootRelativePath}/${targetModule}/${resolvedFileName}`
   );
   return {
@@ -216538,13 +216676,17 @@ async function resolveWorkspacePackageImportTarget(importSpecifier, workspacePac
   }
   return void 0;
 }
-async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, sourceFilePath, importSpecifier, adapter, resolutionContext) {
+async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, sourceFilePath, importSpecifier, adapter, javaImportIndex, resolutionContext) {
   const candidateBasePaths = [];
   let packageAliasTargetModule;
   let packageAliasTargetModuleRoot;
   let isPublicPackageAliasImport = false;
-  const normalizedModulesRoot = normalizePath3(modulesRootRelativePath).replace(/^\/+/, "");
+  const normalizedModulesRoot = normalizePath4(modulesRootRelativePath).replace(/^\/+/, "");
   if (usesJavaImportParser(adapter) && !importSpecifier.startsWith(".")) {
+    const indexedJava = resolveJavaImportFromIndex(importSpecifier, javaImportIndex, workspaceRoot);
+    if (indexedJava) {
+      return indexedJava;
+    }
     const resolvedJava = resolveJavaModuleImport(
       normalizedModulesRoot,
       moduleRoots,
@@ -216641,19 +216783,19 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   const targetModuleEntry = packageAliasTargetModule && packageAliasTargetModuleRoot ? [packageAliasTargetModule, packageAliasTargetModuleRoot] : [...moduleRoots.entries()].filter(([, moduleRoot]) => isPathInsideOrEqual2(resolvedPath, moduleRoot)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
   if (!targetModuleEntry) {
     const standaloneTargetModule = explicitStandaloneModuleByPath.get(
-      normalizePath3(path7.relative(workspaceRoot, resolvedPath))
+      normalizePath4(path7.relative(workspaceRoot, resolvedPath))
     );
     if (!standaloneTargetModule) {
       return void 0;
     }
     return {
       targetModule: standaloneTargetModule,
-      resolvedRelativePath: normalizePath3(path7.relative(workspaceRoot, resolvedPath)),
+      resolvedRelativePath: normalizePath4(path7.relative(workspaceRoot, resolvedPath)),
       isPublicImport: true
     };
   }
   const [targetModule, targetModuleRoot] = targetModuleEntry;
-  const targetSubPath = normalizePath3(path7.relative(targetModuleRoot, resolvedPath));
+  const targetSubPath = normalizePath4(path7.relative(targetModuleRoot, resolvedPath));
   if (targetSubPath === "" || targetSubPath.startsWith("../") || targetSubPath.startsWith("..\\")) {
     return void 0;
   }
@@ -216669,7 +216811,7 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   );
   return {
     targetModule,
-    resolvedRelativePath: normalizePath3(path7.relative(workspaceRoot, resolvedPath)),
+    resolvedRelativePath: normalizePath4(path7.relative(workspaceRoot, resolvedPath)),
     isPublicImport,
     ...isPublicPackageAliasImport ? { isPackagePublicImport: true } : {}
   };
@@ -216680,6 +216822,7 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
   if (!supportsDependencyImportParsing(adapter)) {
     return imports;
   }
+  const javaImportIndex = usesJavaImportParser(adapter) ? await buildJavaImportIndex(workspaceRoot, moduleRoots, adapter) : void 0;
   for (const [moduleName, moduleRoot] of [...moduleRoots.entries()].sort(
     ([left], [right]) => left.localeCompare(right)
   )) {
@@ -216691,7 +216834,7 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
       childModuleRoots
     );
     for (const sourceFilePath of sourceFiles) {
-      const sourceFileRelativePath = normalizePath3(
+      const sourceFileRelativePath = normalizePath4(
         path7.relative(workspaceRoot, sourceFilePath)
       );
       if (!includeTestFiles && isTestSourcePath(sourceFileRelativePath)) {
@@ -216716,6 +216859,7 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
           sourceFilePath,
           importReference.specifier,
           adapter,
+          javaImportIndex,
           options?.resolutionContext
         );
         if (!resolved || resolved.targetModule === moduleName) {
@@ -216956,7 +217100,7 @@ function buildDependencyConfigSkippedFindings(reason, options) {
   return findings;
 }
 function normalizePathList(values) {
-  return values.map((value) => normalizePath3(value)).sort((left, right) => left.localeCompare(right));
+  return values.map((value) => normalizePath4(value)).sort((left, right) => left.localeCompare(right));
 }
 function normalizeModuleContract(contractLike) {
   if (typeof contractLike.module !== "string") {
@@ -217059,7 +217203,7 @@ function buildContractSkipMessage(ruleId, sourceModule, targetModule, sourceCont
   )}.`;
 }
 function isImportWithinPublicEntrypoints(resolvedTargetRelativePath, publicEntrypoints) {
-  const normalizedTargetPath = normalizePath3(resolvedTargetRelativePath);
+  const normalizedTargetPath = normalizePath4(resolvedTargetRelativePath);
   for (const publicEntrypoint of normalizePathList(publicEntrypoints)) {
     const isFileEntrypoint = /\.[a-z0-9]+$/iu.test(publicEntrypoint);
     if (isFileEntrypoint && normalizedTargetPath === publicEntrypoint) {
@@ -217106,17 +217250,18 @@ async function inferExistingPublicEntrypointsFromModuleRoot(workspaceRoot, modul
     const candidatePath = path7.join(moduleRoot, ...candidateSubpath.split("/"));
     if (await pathExists4(candidatePath)) {
       existingEntrypoints.push(
-        normalizePath3(path7.relative(workspaceRoot, candidatePath))
+        normalizePath4(path7.relative(workspaceRoot, candidatePath))
       );
     }
   }
   return existingEntrypoints.sort((left, right) => left.localeCompare(right));
 }
-async function resolveModulePublicEntrypoints(workspaceRoot, architectureContract, moduleName, targetContract, moduleRoots) {
-  const registryPublicEntrypoints = architectureContract.modules[moduleName]?.publicEntrypoints ?? [];
+async function resolveKnownModulePublicEntrypoints(workspaceRoot, architectureContract, moduleName, targetContract, moduleRoots, adapter) {
+  const registryPublicEntrypoints = architectureContract?.modules[moduleName]?.publicEntrypoints ?? [];
+  const contractPublicEntrypoints = targetContract?.publicEntrypoints ?? [];
   const explicitPublicEntrypoints = sortUnique2([
     ...registryPublicEntrypoints,
-    ...targetContract.publicEntrypoints
+    ...contractPublicEntrypoints
   ]);
   const existingExplicitEntrypoints = await filterExistingPublicEntrypoints(
     workspaceRoot,
@@ -217125,13 +217270,16 @@ async function resolveModulePublicEntrypoints(workspaceRoot, architectureContrac
   if (existingExplicitEntrypoints.length > 0) {
     return existingExplicitEntrypoints;
   }
+  if (usesJavaImportParser(adapter)) {
+    return [];
+  }
   return inferExistingPublicEntrypointsFromModuleRoot(
     workspaceRoot,
     moduleRoots.get(moduleName)
   );
 }
 function labelPublicEntrypoint(publicEntrypoint) {
-  const normalizedEntrypoint = normalizePath3(publicEntrypoint);
+  const normalizedEntrypoint = normalizePath4(publicEntrypoint);
   const fileName = normalizedEntrypoint.split("/").at(-1) ?? "";
   return /^index\.[cm]?[jt]sx?$/iu.test(fileName) ? `${fileName} public entrypoint` : "public entrypoint";
 }
@@ -217151,7 +217299,7 @@ async function describeModulePublicImportGuidance(workspaceRoot, moduleName, mod
     return `Use the public entrypoint at ${describePublicEntrypointTargets(inferredEntrypoints)} instead.`;
   }
   if (moduleRoot) {
-    return `Use an existing public entrypoint under ${normalizePath3(path7.relative(workspaceRoot, moduleRoot))} instead.`;
+    return `Use an existing public entrypoint under ${normalizePath4(path7.relative(workspaceRoot, moduleRoot))} instead.`;
   }
   return "Use an existing target module public entrypoint instead.";
 }
@@ -217548,12 +217696,13 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
         }
         continue;
       }
-      const publicEntrypoints = await resolveModulePublicEntrypoints(
+      const publicEntrypoints = await resolveKnownModulePublicEntrypoints(
         workspaceRoot,
         architectureContract,
         dependencyImport.targetModule,
         targetContract.contract,
-        moduleRoots
+        moduleRoots,
+        adapter
       );
       if (publicEntrypoints.length === 0) {
         continue;
@@ -217737,6 +217886,7 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
     (dependencyImport) => isModuleScopedDependencyImport(parsedArchitectureContract, dependencyImport)
   );
   const findings = [];
+  const moduleContractCache = /* @__PURE__ */ new Map();
   let dependencyRules;
   let dependencyRulesSkipReason;
   if (options.dependencyRulesConfigOverride) {
@@ -217853,19 +218003,49 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         })
       );
     } else {
-      const violations = moduleScopedPeerImports.filter((dependencyImport) => {
+      const violations = [];
+      for (const dependencyImport of moduleScopedPeerImports) {
         if (parsedArchitectureContract) {
           const dependencyMetadata = resolveImportDependencyContextMetadata(
             parsedArchitectureContract,
             dependencyImport
           );
           if (dependencyMetadata.isExternal) {
-            return false;
+            continue;
           }
         }
         const moduleRules = dependencyRules.modules[dependencyImport.sourceModule];
-        return moduleRules?.publicEntrypointsOnly === true && !dependencyImport.isPublicImport;
-      });
+        if (moduleRules?.publicEntrypointsOnly !== true || dependencyImport.isPublicImport) {
+          continue;
+        }
+        if (dependencyImport.isPackagePublicImport === true) {
+          continue;
+        }
+        const targetContract = parsedArchitectureContract ? await loadModuleArchitectureContract(
+          workspaceRoot,
+          parsedArchitectureContract,
+          dependencyImport.targetModule,
+          moduleContractCache
+        ) : void 0;
+        const publicEntrypoints = await resolveKnownModulePublicEntrypoints(
+          workspaceRoot,
+          parsedArchitectureContract,
+          dependencyImport.targetModule,
+          targetContract?.contract,
+          moduleRoots,
+          adapter
+        );
+        if (publicEntrypoints.length === 0) {
+          continue;
+        }
+        if (isImportWithinPublicEntrypoints(
+          dependencyImport.resolvedTargetRelativePath,
+          publicEntrypoints
+        )) {
+          continue;
+        }
+        violations.push(dependencyImport);
+      }
       if (violations.length === 0) {
         findings.push({
           result: makeValidationResult(
@@ -218014,6 +218194,7 @@ var init_dependencyValidation = __esm({
     init_architectureDependencyContext();
     init_moduleDiscovery();
     init_stackAdapters();
+    init_sourceScopeClassification();
     dependencyRulesConfigFile = ".archpilot/dependency-rules.json";
     DependencyRulesConfigError = class extends Error {
     };
@@ -218021,7 +218202,7 @@ var init_dependencyValidation = __esm({
 });
 
 // ../core/src/moduleScope.ts
-function normalizePath4(value) {
+function normalizePath5(value) {
   return value.replace(/\\/g, "/").replace(/^\.\/+/u, "").replace(/\/+$/u, "").toLowerCase();
 }
 function pathExists5(targetPath) {
@@ -218074,7 +218255,7 @@ function hasJsxEnabled(configPath) {
   return typeof jsx === "string" && jsx.trim().length > 0;
 }
 function listPathSegments(modulePath) {
-  return normalizePath4(modulePath).split("/").filter((entry) => entry.length > 0);
+  return normalizePath5(modulePath).split("/").filter((entry) => entry.length > 0);
 }
 function getCandidateRoots(workspaceRoot, modulePath) {
   const resolvedWorkspaceRoot = path8.resolve(workspaceRoot);
@@ -218406,9 +218587,12 @@ var init_moduleScope = __esm({
 });
 
 // ../core/src/smartInit/moduleDetection.ts
-function normalizePath5(value) {
+function normalizePath6(value) {
   return value.replaceAll("\\", "/");
 }
+function isUnderJvmResourceRoot(relativePath) {
+  return /(^|\/)src\/main\/resources(?:\/|$)/u.test(normalizePath6(relativePath).toLowerCase());
+}
 function safeReadDirEntries(directoryPath) {
   try {
     return fs8.readdirSync(directoryPath, { withFileTypes: true });
@@ -218425,7 +218609,7 @@ function pathExists6(pathValue) {
   }
 }
 function isIgnoredPath(context, relativePath) {
-  return context?.ignoreMatcher?.isIgnored(normalizePath5(relativePath)) ?? false;
+  return context?.ignoreMatcher?.isIgnored(normalizePath6(relativePath)) ?? false;
 }
 function uniqueSorted(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
@@ -218440,15 +218624,15 @@ function normalizeIdentity(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/gu, "");
 }
 function pathLeafIdentity(value) {
-  const normalized = normalizePath5(value).replace(/\/+$/gu, "");
+  const normalized = normalizePath6(value).replace(/\/+$/gu, "");
   const leaf = normalized.split("/").filter((segment) => segment.length > 0).at(-1) ?? normalized;
   return normalizeIdentity(leaf);
 }
 function getComponentAlignedEvidence(input2) {
-  const modulePath = normalizePath5(input2.modulePath).replace(/\/+$/gu, "");
+  const modulePath = normalizePath6(input2.modulePath).replace(/\/+$/gu, "");
   const moduleNameIdentity = normalizeIdentity(input2.moduleName);
   const modulePathLeaf = pathLeafIdentity(modulePath);
-  const matchingPath = input2.context?.componentPaths?.map((entry) => normalizePath5(entry).replace(/\/+$/gu, "")).find(
+  const matchingPath = input2.context?.componentPaths?.map((entry) => normalizePath6(entry).replace(/\/+$/gu, "")).find(
     (componentPath) => componentPath.length > 0 && componentPath !== "." && (componentPath === modulePath || componentPath.startsWith(`${modulePath}/`))
   );
   if (matchingPath) {
@@ -218458,7 +218642,7 @@ function getComponentAlignedEvidence(input2) {
   if (matchingName) {
     return `Matches detected component/service/app identity ${input2.moduleName}`;
   }
-  const matchingResourcePath = input2.context?.resourcePaths?.map((entry) => normalizePath5(entry).replace(/\/+$/gu, "")).find(
+  const matchingResourcePath = input2.context?.resourcePaths?.map((entry) => normalizePath6(entry).replace(/\/+$/gu, "")).find(
     (resourcePath) => resourcePath.length > 0 && resourcePath !== "." && (resourcePath === modulePath || resourcePath.startsWith(`${modulePath}/`))
   );
   if (matchingResourcePath) {
@@ -218638,6 +218822,9 @@ function containsAppRouteFiles(absolutePath) {
   return false;
 }
 function makeDetectedModule(workspaceRoot, moduleName, modulePath, rootPath, hasSourceFiles, hasRoleFiles, sourceFileCount, context) {
+  if (isUnderJvmResourceRoot(modulePath)) {
+    return void 0;
+  }
   const evidence = [];
   if (hasSourceFiles) {
     evidence.push("Contains source files");
@@ -218696,11 +218883,14 @@ function collectModuleCandidatesFromRoot(workspaceRoot, modulesRootRelative, def
   const rootLower = modulesRootRelative.toLowerCase();
   const skipFrontendUtilities = rootLower === "src/features" || rootLower.endsWith("/src/features") || rootLower === "app" || rootLower === "src/app" || rootLower.endsWith("/app") || rootLower.endsWith("/src/app");
   const entries = safeReadDirEntries(absoluteRoot).filter(
-    (entry) => entry.isDirectory() && !ignoredDirectoryNames.has(entry.name) && !isIgnoredPath(context, normalizePath5(`${modulesRootRelative}/${entry.name}`))
+    (entry) => entry.isDirectory() && !ignoredDirectoryNames.has(entry.name) && !isIgnoredPath(context, normalizePath6(`${modulesRootRelative}/${entry.name}`))
   ).sort((left, right) => left.name.localeCompare(right.name));
   const modules = [];
   for (const entry of entries) {
-    const candidateProjectRoot = normalizePath5(`${modulesRootRelative}/${entry.name}`);
+    const candidateProjectRoot = normalizePath6(`${modulesRootRelative}/${entry.name}`);
+    if (isUnderJvmResourceRoot(candidateProjectRoot)) {
+      continue;
+    }
     if (["apps", "packages", "services", "libs"].includes(rootLower) && (context?.projectRoots?.length ?? 0) > 0 && !context?.projectRoots?.includes(candidateProjectRoot)) {
       continue;
     }
@@ -218717,7 +218907,7 @@ function collectModuleCandidatesFromRoot(workspaceRoot, modulesRootRelative, def
     const detected = makeDetectedModule(
       workspaceRoot,
       moduleName,
-      normalizePath5(`${modulesRootRelative}/${entry.name}`),
+      normalizePath6(`${modulesRootRelative}/${entry.name}`),
       modulesRootRelative,
       inspected.hasSourceFiles,
       inspected.hasRoleFiles,
@@ -218740,7 +218930,7 @@ function collectAppRouteModules(workspaceRoot, appRootRelative, context) {
     return [];
   }
   const entries = safeReadDirEntries(absoluteRoot).filter(
-    (entry) => entry.isDirectory() && !ignoredDirectoryNames.has(entry.name) && !isIgnoredPath(context, normalizePath5(`${appRootRelative}/${entry.name}`))
+    (entry) => entry.isDirectory() && !ignoredDirectoryNames.has(entry.name) && !isIgnoredPath(context, normalizePath6(`${appRootRelative}/${entry.name}`))
   ).sort((left, right) => left.name.localeCompare(right.name));
   const modules = [];
   for (const entry of entries) {
@@ -218754,7 +218944,7 @@ function collectAppRouteModules(workspaceRoot, appRootRelative, context) {
     if (!moduleName || frontendUtilityDirectoryNames.has(moduleName.toLowerCase())) {
       continue;
     }
-    const moduleRelativePath = normalizePath5(`${appRootRelative}/${rawName}`);
+    const moduleRelativePath = normalizePath6(`${appRootRelative}/${rawName}`);
     const moduleAbsolutePath = path9.join(absoluteRoot, rawName);
     if (!containsAppRouteFiles(moduleAbsolutePath)) {
       continue;
@@ -218881,14 +219071,14 @@ function collectJavaPackageRoots(workspaceRoot, context) {
         continue;
       }
       for (const entry of safeReadDirEntries(current.absolutePath)) {
-        const childRelativePath = normalizePath5(`${current.relativePath}/${entry.name}`);
+        const childRelativePath = normalizePath6(`${current.relativePath}/${entry.name}`);
         if (!entry.isDirectory() || ignoredDirectoryNames.has(entry.name) || isIgnoredPath(context, childRelativePath)) {
           continue;
         }
         const lowerName = entry.name.toLowerCase();
         if (lowerName === "modules" || lowerName === "features") {
           const childCount = safeReadDirEntries(path9.join(current.absolutePath, entry.name)).filter(
-            (child) => child.isDirectory() && !ignoredDirectoryNames.has(child.name) && !isIgnoredPath(context, normalizePath5(`${childRelativePath}/${child.name}`))
+            (child) => child.isDirectory() && !ignoredDirectoryNames.has(child.name) && !isIgnoredPath(context, normalizePath6(`${childRelativePath}/${child.name}`))
           ).length;
           if (childCount >= 2) {
             roots.push(childRelativePath);
@@ -218947,10 +219137,10 @@ function detectModules(workspaceRoot, options) {
     projectKinds: options?.projectKinds,
     stacks: options?.stacks,
     ignoreMatcher: options?.ignoreMatcher,
-    projectRoots: options?.projectRoots?.map(normalizePath5),
-    componentPaths: options?.componentPaths?.map(normalizePath5),
+    projectRoots: options?.projectRoots?.map(normalizePath6),
+    componentPaths: options?.componentPaths?.map(normalizePath6),
     componentNames: options?.componentNames,
-    resourcePaths: options?.resourcePaths?.map(normalizePath5),
+    resourcePaths: options?.resourcePaths?.map(normalizePath6),
     resourceNames: options?.resourceNames
   };
   const explicitRoots = collectExplicitRoots(workspaceRoot, context);
@@ -219028,7 +219218,7 @@ function detectModules(workspaceRoot, options) {
   };
 }
 function detectModuleCandidatesForRoot(workspaceRoot, modulesRootRelative, options) {
-  const normalizedRoot = normalizePath5(modulesRootRelative.trim()).replace(/^\/+|\/+$/gu, "");
+  const normalizedRoot = normalizePath6(modulesRootRelative.trim()).replace(/^\/+|\/+$/gu, "");
   if (normalizedRoot.length === 0) {
     return [];
   }
@@ -219040,10 +219230,10 @@ function detectModuleCandidatesForRoot(workspaceRoot, modulesRootRelative, optio
       projectKinds: options?.projectKinds,
       stacks: options?.stacks,
       ignoreMatcher: options?.ignoreMatcher,
-      projectRoots: options?.projectRoots?.map(normalizePath5),
-      componentPaths: options?.componentPaths?.map(normalizePath5),
+      projectRoots: options?.projectRoots?.map(normalizePath6),
+      componentPaths: options?.componentPaths?.map(normalizePath6),
       componentNames: options?.componentNames,
-      resourcePaths: options?.resourcePaths?.map(normalizePath5),
+      resourcePaths: options?.resourcePaths?.map(normalizePath6),
       resourceNames: options?.resourceNames
     }
   );
@@ -219084,6 +219274,7 @@ var init_moduleDetection = __esm({
       "scripts",
       "test",
       "tests",
+      "cypress-tests",
       "__tests__",
       "fixtures",
       "docs",
@@ -219307,7 +219498,7 @@ var init_moduleDetection = __esm({
 });
 
 // ../core/src/architectureMap.ts
-function normalizePath6(value) {
+function normalizePath7(value) {
   return value.replace(/\\/g, "/");
 }
 async function pathExists7(targetPath) {
@@ -219329,7 +219520,7 @@ function sortUnique3(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
 function toSafeContractModuleFileStem2(moduleName) {
-  return normalizePath6(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
+  return normalizePath7(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
 }
 function getModuleRegistry(contract) {
   const modules = contract?.modules;
@@ -219374,7 +219565,7 @@ function hasExplicitModuleRegistry(config) {
   );
 }
 function normalizePublicEntrypointList(entries) {
-  return sortUnique3(entries.map((entry) => normalizePath6(entry.trim())).filter((entry) => entry.length > 0));
+  return sortUnique3(entries.map((entry) => normalizePath7(entry.trim())).filter((entry) => entry.length > 0));
 }
 function hasConfiguredPublicEntrypoint(registryEntry) {
   return Array.isArray(registryEntry?.publicEntrypoints) && registryEntry.publicEntrypoints.some(
@@ -219484,10 +219675,10 @@ function parseCycleString(cycle) {
 }
 async function discoverModulesFromArchitectureContract(workspaceRoot, contract, modulesRoot) {
   const moduleRegistry = getModuleRegistry(contract);
-  const normalizedModulesRoot = normalizePath6(modulesRoot);
-  const contractsRoot = normalizePath6(contract.structure.contractsRoot ?? ".archpilot/contracts");
+  const normalizedModulesRoot = normalizePath7(modulesRoot);
+  const contractsRoot = normalizePath7(contract.structure.contractsRoot ?? ".archpilot/contracts");
   const discovered = [];
-  const toContractPath = (moduleName, registryEntry) => normalizePath6(
+  const toContractPath = (moduleName, registryEntry) => normalizePath7(
     typeof registryEntry?.contract === "string" ? registryEntry.contract : `${contractsRoot}/${toSafeContractModuleFileStem2(moduleName)}.contract.json`
   );
   const resolveMissingPublicEntrypointAlignment = async (registryEntry, contractPath) => {
@@ -219515,7 +219706,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
     if (!registryEntry.path || typeof registryEntry.path !== "string") {
       continue;
     }
-    const normalizedSourcePath = normalizePath6(registryEntry.path);
+    const normalizedSourcePath = normalizePath7(registryEntry.path);
     const absoluteSourcePath = path10.join(workspaceRoot, ...normalizedSourcePath.split("/"));
     let sourcePathExists = false;
     let sourceIsDirectory = false;
@@ -219531,7 +219722,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
     if (!sourceIsDirectory && !sourceIsFile) {
       continue;
     }
-    const contractPath = normalizePath6(
+    const contractPath = normalizePath7(
       typeof registryEntry.contract === "string" ? registryEntry.contract : `${contractsRoot}/${toSafeContractModuleFileStem2(moduleName)}.contract.json`
     );
     const contractExists = await pathExists7(path10.join(workspaceRoot, ...contractPath.split("/")));
@@ -219615,7 +219806,7 @@ function getComponentEntries(contract) {
     }
     const typed = value;
     const componentId = typeof typed.id === "string" && typed.id.trim().length > 0 ? typed.id.trim() : typeof key === "string" && key.trim().length > 0 ? key.trim() : void 0;
-    const sourcePath = typeof typed.path === "string" && typed.path.trim().length > 0 ? normalizePath6(typed.path.trim()) : void 0;
+    const sourcePath = typeof typed.path === "string" && typed.path.trim().length > 0 ? normalizePath7(typed.path.trim()) : void 0;
     if (!componentId || !sourcePath || sourcePath === ".") {
       continue;
     }
@@ -219740,7 +219931,7 @@ async function generateArchitectureMap(workspaceRoot, options) {
   const shouldUseConfiguredRootInference = hasArchitectureJson && !contractHasConfiguredModules && !hasExplicitEmptyModuleRegistry && hasExplicitModuleRootConfig(rawArchitectureConfig);
   const shouldUseTopLevelWorkspaceInference = hasArchitectureJson && !contractHasConfiguredModules && !hasExplicitEmptyModuleRegistry && !shouldUseConfiguredRootInference;
   const discoveryMode = hasArchitectureJson ? "architecture-json" : "inferred-src-modules";
-  const modulesRoot = normalizePath6(
+  const modulesRoot = normalizePath7(
     await resolveConfiguredModulesRoot(
       workspaceRoot,
       resolveModulesRootFromContract(contract)
@@ -220638,7 +220829,7 @@ var init_archpilotIgnore = __esm({
 });
 
 // ../core/src/moduleContractsGenerator.ts
-function normalizePath7(value) {
+function normalizePath8(value) {
   return value.replace(/\\/g, "/");
 }
 function toAbsolutePath(workspaceRoot, relativePath) {
@@ -220656,7 +220847,7 @@ function sortUnique4(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
 function toSafeContractModuleFileStem3(moduleName) {
-  return normalizePath7(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
+  return normalizePath8(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
 }
 function wildcardToRegex(pattern) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
@@ -220670,14 +220861,14 @@ function getModuleRegistry2(contract) {
   return modules;
 }
 async function inferModulePublicEntrypoints(workspaceRoot, moduleSourcePath, adapter) {
-  const normalizedSourcePath = normalizePath7(moduleSourcePath);
+  const normalizedSourcePath = normalizePath8(moduleSourcePath);
   if (/\.[a-z0-9]+$/iu.test(normalizedSourcePath)) {
     const absoluteSourcePath = toAbsolutePath(workspaceRoot, normalizedSourcePath);
     if (await pathExists8(absoluteSourcePath)) {
       return [normalizedSourcePath];
     }
   }
-  const candidateFiles = adapter.defaultEntrypointHints.map((hint) => normalizePath7(hint)).filter((hint) => !hint.includes("/"));
+  const candidateFiles = adapter.defaultEntrypointHints.map((hint) => normalizePath8(hint)).filter((hint) => !hint.includes("/"));
   const exactCandidates = candidateFiles.filter((hint) => !hint.includes("*"));
   const wildcardCandidates = candidateFiles.filter((hint) => hint.includes("*"));
   const resolvedWildcardCandidates = [];
@@ -220712,10 +220903,6 @@ async function inferModulePublicEntrypoints(workspaceRoot, moduleSourcePath, ada
       break;
     }
   }
-  if (inferred.length === 0) {
-    const fallbackName = adapter.scaffoldingDefaults?.moduleIndexFileName ?? orderedCandidates.find((entry) => entry.startsWith("index.")) ?? "index.ts";
-    inferred.push(`${normalizedSourcePath}/${fallbackName}`);
-  }
   return sortUnique4(inferred);
 }
 function buildDependsOnBySource(edges) {
@@ -220736,9 +220923,9 @@ function resolveContractPath(contract, moduleName) {
   const moduleRegistry = getModuleRegistry2(contract);
   const configured = moduleRegistry[moduleName]?.contract;
   if (configured && configured.trim().length > 0) {
-    return normalizePath7(configured);
+    return normalizePath8(configured);
   }
-  return normalizePath7(
+  return normalizePath8(
     path15.posix.join(
       resolveContractsRootFromContract(contract),
       `${toSafeContractModuleFileStem3(moduleName)}.contract.json`
@@ -220769,7 +220956,7 @@ async function readExistingModuleContractPublicEntrypoints(workspaceRoot, contra
     if (parsed.publicEntrypoints.some((entry) => typeof entry !== "string")) {
       return void 0;
     }
-    return sortUnique4(parsed.publicEntrypoints.map((entry) => normalizePath7(entry)));
+    return sortUnique4(parsed.publicEntrypoints.map((entry) => normalizePath8(entry)));
   } catch {
     return void 0;
   }
@@ -220832,14 +221019,14 @@ async function generateMissingModuleContracts(workspaceRoot) {
     (left, right) => left.moduleName.localeCompare(right.moduleName)
   )) {
     const contractPath = resolveContractPath(contract, moduleEntry.moduleName);
-    const sourcePath = normalizePath7(moduleEntry.sourcePath);
+    const sourcePath = normalizePath8(moduleEntry.sourcePath);
     const absoluteContractPath = toAbsolutePath(workspaceRoot, contractPath);
     const contractExists = await pathExists8(absoluteContractPath);
     const existingContract = contractExists ? await readExistingModuleContract(workspaceRoot, contractPath) : void 0;
     const existingContractPublicEntrypoints = contractExists ? await readExistingModuleContractPublicEntrypoints(workspaceRoot, contractPath) : void 0;
     const configuredPublicEntrypoints = !contractExists && Array.isArray(getModuleRegistry2(contract)[moduleEntry.moduleName]?.publicEntrypoints) ? sortUnique4(
       getModuleRegistry2(contract)[moduleEntry.moduleName]?.publicEntrypoints?.map(
-        (entry) => normalizePath7(entry)
+        (entry) => normalizePath8(entry)
       ) ?? []
     ) : void 0;
     const publicEntrypoints = existingContractPublicEntrypoints ?? configuredPublicEntrypoints ?? await inferModulePublicEntrypoints(
@@ -220941,7 +221128,7 @@ var bootstrapArchitectureConfig_exports = {};
 __export(bootstrapArchitectureConfig_exports, {
   bootstrapArchitectureConfig: () => bootstrapArchitectureConfig
 });
-function normalizePath8(value) {
+function normalizePath9(value) {
   return value.replace(/\\/g, "/");
 }
 function toAbsolutePath2(workspaceRoot, relativePath) {
@@ -221044,9 +221231,9 @@ async function bootstrapArchitectureConfig(workspaceRoot, options) {
     }
   }
   return {
-    createdFiles: sortUnique5(createdFiles.map((entry) => normalizePath8(entry))),
-    ensuredDirectories: sortUnique5(ensuredDirectories.map((entry) => normalizePath8(entry))),
-    skippedExistingFiles: sortUnique5(skippedExistingFiles.map((entry) => normalizePath8(entry))),
+    createdFiles: sortUnique5(createdFiles.map((entry) => normalizePath9(entry))),
+    ensuredDirectories: sortUnique5(ensuredDirectories.map((entry) => normalizePath9(entry))),
+    skippedExistingFiles: sortUnique5(skippedExistingFiles.map((entry) => normalizePath9(entry))),
     moduleCount: modules.length,
     ...contractGeneration ? { contractGeneration } : {},
     ...contractGenerationSkippedReason ? { contractGenerationSkippedReason } : {}
@@ -221871,7 +222058,15 @@ function formatArchitectureDriftSummaryMessage(areas) {
   }
   return `Architecture drift detected in ${labels.slice(0, -1).join(", ")}, and ${labels.at(-1)}.`;
 }
-function buildArchitectureDriftSummary(results, _suppressedResults = []) {
+function buildArchitectureDriftSummary(results, _suppressedResults = [], options = {}) {
+  if (options.baselineAvailable !== true) {
+    return {
+      detected: false,
+      areas: [],
+      message: "No comparison baseline available; architecture drift was not evaluated.",
+      baselineAvailable: false
+    };
+  }
   const activeFailedResults = results.filter(
     (result) => !result.passed && result.severity !== "info"
   );
@@ -221879,7 +222074,8 @@ function buildArchitectureDriftSummary(results, _suppressedResults = []) {
   return {
     detected: areas.length > 0,
     areas,
-    message: formatArchitectureDriftSummaryMessage(areas)
+    message: formatArchitectureDriftSummaryMessage(areas),
+    baselineAvailable: true
   };
 }
 
@@ -222179,7 +222375,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
 var path19 = __toESM(require("node:path"));
 var import_node_fs15 = require("node:fs");
 var suppressionsRelativePath = ".archpilot/suppressions.json";
-function normalizePath9(value) {
+function normalizePath10(value) {
   let normalized = value.replace(/\\/g, "/").trim();
   while (normalized.startsWith("./")) {
     normalized = normalized.slice(2);
@@ -222217,8 +222413,8 @@ function globToRegex(pattern) {
   return new RegExp(expression, "u");
 }
 function isSuppressionPathMatch(pattern, findingPath) {
-  const normalizedPattern = normalizePath9(pattern);
-  const normalizedFindingPath = normalizePath9(findingPath);
+  const normalizedPattern = normalizePath10(pattern);
+  const normalizedFindingPath = normalizePath10(findingPath);
   if (!normalizedPattern || !normalizedFindingPath) {
     return false;
   }
@@ -222321,7 +222517,7 @@ async function readValidationSuppressions(workspaceRoot, knownRuleIds) {
       ignored.push({
         index,
         ruleId,
-        ...entryScopeValue ? { scope: normalizePath9(entryScopeValue) } : {},
+        ...entryScopeValue ? { scope: normalizePath10(entryScopeValue) } : {},
         reason: "Unknown rule ID. Entry was ignored.",
         ...expiresOn ? { expiresOn } : {}
       });
@@ -222330,7 +222526,7 @@ async function readValidationSuppressions(workspaceRoot, knownRuleIds) {
     suppressions.push({
       index,
       ruleId,
-      ...entryScopeValue ? { scope: normalizePath9(entryScopeValue) } : {},
+      ...entryScopeValue ? { scope: normalizePath10(entryScopeValue) } : {},
       ...reason ? { reason } : {},
       ...expiresOn ? { expiresOn } : {}
     });
@@ -225107,66 +225303,8 @@ async function profileValidationPhase(label, run, details) {
   }
 }
 
-// ../core/src/sourceScopeClassification.ts
-function normalizePath10(value) {
-  return value.replace(/\\/g, "/").toLowerCase();
-}
-function hasPathSegment(pathValue, pattern) {
-  return pathValue.split("/").some((segment) => pattern.test(segment));
-}
-function classifyValidationSourceScope(relativePath) {
-  const normalized = normalizePath10(relativePath);
-  const fileName = normalized.split("/").at(-1) ?? normalized;
-  const extension = fileName.includes(".") ? fileName.slice(fileName.lastIndexOf(".")) : "";
-  const isTestFile = /\.(?:spec|test|e2e-spec)\.(?:ts|tsx|js|jsx|mjs|cjs|java|cs|py|php|go)$/u.test(fileName);
-  const isE2e = isTestFile && /(?:^|[./_-])e2e(?:[./_-]|$)/u.test(fileName) || hasPathSegment(normalized, /^e2e$/u);
-  const isFixture = hasPathSegment(normalized, /^(?:fixtures?|__fixtures__)$/u);
-  const isTestPlugin = hasPathSegment(normalized, /^(?:test-plugins?|testing-plugins?)$/u);
-  const isExamplePlugin = hasPathSegment(normalized, /^(?:example-plugins?|examples?)$/u);
-  const isGenerated = hasPathSegment(normalized, /^(?:generated|__generated__|gen|templates?)$/u) || /\.(?:generated|gen|g)\.(?:ts|tsx|js|jsx|java|cs|py|php|go)$/u.test(fileName) || /\.d\.ts$/u.test(fileName);
-  const isMigration = hasPathSegment(normalized, /^(?:migrations?|schema-migrations?|migration-utils?)$/u) || /(?:^|[./_-])migration(?:[./_-]|$)/u.test(fileName);
-  const isCliTooling = hasPathSegment(normalized, /^(?:cli|bin|scripts?|tools?|scaffold|scaffolding|generators?)$/u) || /(?:^|[./_-])(?:cli|script|tool|generator|scaffold)(?:[./_-]|$)/u.test(fileName);
-  const isFrontend = extension === ".tsx" || extension === ".jsx" || hasPathSegment(normalized, /^(?:frontend|client|browser|ui|admin-ui|dashboard|web-app)$/u) || /\b(?:react|angular|vue|svelte)\b/u.test(normalized);
-  const isInfrastructure = hasPathSegment(normalized, /^(?:infrastructure|infra|framework|adapters?|persistence|providers?)$/u) || /(?:transactional-connection|transaction-wrapper|transaction-subscriber|transaction-manager|query-runner|query-builder|event-bus|telemetry|interceptor)\.(?:ts|js|java|cs|py|php|go)$/u.test(fileName);
-  let category = "production-backend";
-  if (isGenerated) {
-    category = "generated";
-  } else if (isE2e) {
-    category = "e2e";
-  } else if (isTestFile || hasPathSegment(normalized, /^(?:test|tests|__tests__|spec|specs)$/u)) {
-    category = "test";
-  } else if (isTestPlugin) {
-    category = "test-plugin";
-  } else if (isExamplePlugin) {
-    category = "example-plugin";
-  } else if (isFixture) {
-    category = "fixture";
-  } else if (isMigration) {
-    category = "migration";
-  } else if (isCliTooling) {
-    category = "cli-tooling";
-  } else if (isFrontend) {
-    category = "production-frontend";
-  } else if (isInfrastructure) {
-    category = "infrastructure";
-  }
-  const isTestLike = category === "test" || category === "e2e" || category === "fixture" || category === "test-plugin" || category === "example-plugin";
-  return {
-    category,
-    isProduction: category === "production-backend" || category === "production-frontend" || category === "infrastructure",
-    isFrontend: category === "production-frontend",
-    isTestLike,
-    isGenerated: category === "generated",
-    isMigration: category === "migration",
-    isCliTooling: category === "cli-tooling",
-    isInfrastructure: category === "infrastructure"
-  };
-}
-function isProductionBackendGovernanceScope(scope) {
-  return scope.category === "production-backend";
-}
-
 // ../core/src/dataQueryRiskDetection.ts
+init_sourceScopeClassification();
 var maxFileSizeBytes = 256 * 1024;
 var supplementalRiskScanExtensions = [".json", ".yaml", ".yml", ".sql"];
 var backendCodeExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".java", ".cs", ".py", ".php", ".go"];
@@ -225174,7 +225312,7 @@ var supplementalIgnoredDirectoryNames = [".vscode-test", ".tmp"];
 var batchingEvidencePattern = /\b(?:DataLoader|Promise\.all|findMany\s*\([\s\S]{0,300}\bin\b|where\s*:\s*\{[\s\S]{0,300}\bin\s*:|include\s*:|join\s*\(|leftJoin|innerJoin|JOIN\b)\b/iu;
 var queryReadPattern = /\b((?:this\.)?(?:prisma\.(\w+)|([A-Za-z_$][\w$]*Repository|repository))\.(find\w*|count|aggregate|groupBy)\s*\()/giu;
 var unboundedLoadPattern = /\b(?:const|let|var)\s+(\w+)\s*=\s*await\s+((?:this\.)?(?:prisma\.\w+|\w*Repository|repository)\.(?:findMany|findAll|find))\s*\(([\s\S]{0,700}?)\)\s*;?[\s\S]{0,1000}\b\1\.(?:filter|map|reduce)\s*\(/iu;
-var boundEvidencePattern = /\b(?:take|limit|page|cursor|skip|offset|PageRequest|Pageable)\b/iu;
+var boundEvidencePattern = /\b(?:take|limit|page|cursor|skip|offset|PageRequest|Pageable|findOne|findOneOrFail|findOneBy|findOneByOrFail|findUnique|findFirst|getOne|getRawOne|first)\b/iu;
 var repeatedQueryPattern = /\b((?:this\.)?(?:prisma\.(\w+)|(\w*Repository|repository))\.(find\w*|count|aggregate|groupBy)\s*\(\s*(?:\{[\s\S]{0,300}?\}|\w+)\s*\))/giu;
 var tenantPredicatePattern = /\b(?:tenantId|tenant_id|organizationId|organization_id|orgId|org_id|accountId|account_id|workspaceId|workspace_id|companyId|company_id|customerId|customer_id)\b/u;
 var codePaginationEvidencePattern = /\b(?:take|skip|limit|offset|page|perPage|pageSize|cursor|Pageable|PageRequest|paginate|simplePaginate|Limit|Offset|Take|Skip|TOP\s+\d+)\b/iu;
@@ -225985,7 +226123,7 @@ function detectRepeatedQueryPattern(method) {
 function extractSqlQueryLiterals(content) {
   const queries = [];
   const patterns = [
-    /(?:\b(?:query|execute|executeQuery|createNativeQuery|createQuery|FromSqlRaw|FromSqlInterpolated|Query|QueryContext|QueryRow|QueryRowContext|Exec|ExecContext|Raw|text)|\$queryRaw|\$executeRaw)\s*\([^'"`)]{0,180}?(['"`])([\s\S]{0,900}?)\1/giu,
+    /(?:\b(?:[\w$]+\.)?(?:query|execute|executeQuery|createNativeQuery|createQuery|FromSqlRaw|FromSqlInterpolated|Query|QueryContext|QueryRow|QueryRowContext|Exec|ExecContext|Raw|text)|\$queryRaw|\$executeRaw)\s*\([^'"`)]{0,180}?(['"`])([\s\S]{0,900}?)\1/giu,
     /\b(?:DB::select|DB::statement|DB::raw|DB::table)\s*\([^'"`)]{0,180}?(['"`])([\s\S]{0,900}?)\1/gu,
     /@Query\s*\(\s*(['"`])([\s\S]{0,900}?)\1/gu
   ];
@@ -226072,7 +226210,7 @@ function collectOrmReadEvidence(method) {
   return evidence;
 }
 function getOrmTerminalOperation(snippet) {
-  const match = /\.(getMany|getRawMany|getOne|getRawOne|getCount|getExists|execute|findOne|findOneBy|findUnique|findFirst|count|exists|update|delete|remove|save|insert)\s*\(/iu.exec(snippet);
+  const match = /\.(getMany|getRawMany|loadMany|getOne|getRawOne|loadOne|getCount|getExists|execute|findOne|findOneOrFail|findOneBy|findOneByOrFail|findUnique|findFirst|count|exists|update|delete|remove|save|insert)\s*\(/iu.exec(snippet);
   return match?.[1];
 }
 function isOperationalOrBatchQueryContext(file, methodName) {
@@ -226081,12 +226219,20 @@ function isOperationalOrBatchQueryContext(file, methodName) {
   const method = methodName?.toLowerCase() ?? "";
   return segments.some((segment) => /\b(?:health|cache|job|queue|scheduler|indexer|telemetry|metrics)\b/u.test(segment.replace(/-/g, " "))) || /(^|\/)(?:health-check|healthchecks?|cache|job-queue|scheduler|search|indexer|telemetry|metrics)(?:\/|-)/u.test(pathValue) || /(?:health-check|healthcheck|cache|job-queue|scheduler|search|indexer|telemetry|metrics)\.(?:ts|tsx|js|jsx|java|cs|py|php|go)$/u.test(pathValue) || /\b(?:health|cache|job|queue|schedule|scheduler|index|telemetry|metrics|buffer|worker|batch)\b/u.test(method) || method.includes("batch") || /^on(?:moduleinit|applicationbootstrap|applicationstart|init)$/u.test(method);
 }
-function isPointLookupMethodName(methodName) {
-  return /^(?:getorcreate|findone|findby|getby|loadby|resolveby)/iu.test(methodName);
+function isScopedRelationLoad(snippet) {
+  return /\.relation\s*\(/iu.test(snippet) && /\.of\s*\(\s*[^)]{1,180}\)\s*\.loadMany\s*\(/iu.test(snippet);
+}
+function hasAssignedBuilderBoundedTerminal(methodBody, snippet) {
+  const variableMatch = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:[\s\S]{0,240}?)createQueryBuilder\s*\(/iu.exec(snippet);
+  const variableName = variableMatch?.[1];
+  if (!variableName) {
+    return false;
+  }
+  return new RegExp(`\\b${variableName}\\s*\\.\\s*(?:getOne|getRawOne|loadOne|getCount|getExists)\\s*\\(`, "iu").test(methodBody);
 }
-function isNonCollectionOrmRead(label, snippet) {
+function isNonCollectionOrmRead(label, snippet, methodBody = snippet) {
   const terminal = getOrmTerminalOperation(snippet);
-  return /\b(?:findOne|findOneBy|findUnique|findFirst|count|exists|aggregate)\b/iu.test(label) || !!terminal && /^(?:getOne|getRawOne|getCount|getExists|findOne|findOneBy|findUnique|findFirst|count|exists|update|delete|remove|save|insert|execute)$/iu.test(terminal);
+  return /\b(?:findOne|findOneOrFail|findOneBy|findOneByOrFail|findUnique|findFirst|count|exists|aggregate)\b/iu.test(label) || !!terminal && /^(?:getOne|getRawOne|loadOne|getCount|getExists|findOne|findOneOrFail|findOneBy|findOneByOrFail|findUnique|findFirst|count|exists|update|delete|remove|save|insert|execute)$/iu.test(terminal) || isScopedRelationLoad(snippet) || hasAssignedBuilderBoundedTerminal(methodBody, snippet);
 }
 function hasOrmBoundEvidence(snippet) {
   return codePaginationEvidencePattern.test(snippet) || /\.(?:take|limit|offset|skip)\s*\(/iu.test(snippet) || /\b(?:maxResults|setMaxResults|firstResult|setFirstResult)\s*\(/iu.test(snippet) || /\b(?:pageSize|perPage|limit|take)\s*[:=]\s*\d+\b/iu.test(snippet);
@@ -226121,7 +226267,7 @@ function detectOrmQueryShapeFindings(method, config) {
         target: evidence.label
       }));
     }
-    if (!isOperationalOrBatchQueryContext(method.file, method.name) && !isPointLookupMethodName(method.name) && !isNonCollectionOrmRead(evidence.label, evidence.snippet) && !hasOrmBoundEvidence(evidence.snippet)) {
+    if (!isOperationalOrBatchQueryContext(method.file, method.name) && !isNonCollectionOrmRead(evidence.label, evidence.snippet, method.body) && !hasOrmBoundEvidence(evidence.snippet)) {
       const target = getOrmQueryTarget(method, evidence.label, evidence.snippet);
       const label = getOrmQueryLabel(method, evidence.label, evidence.snippet);
       findings.push(createCodeFinding({
@@ -226146,9 +226292,12 @@ function detectCodeQueryRiskFindings(files, config, astCache) {
       findings.push(...detectCodeSqlQueryShapeFindings(file, config));
     }
     for (const method of extractMethodBodies(file, astCache)) {
+      if (!isProductionBackend) {
+        continue;
+      }
       nPlusOneEvidence.push(...detectNPlusOneQueryRisk(method));
       findings.push(
-        ...isProductionBackend ? detectOrmQueryShapeFindings(method, config) : [],
+        ...detectOrmQueryShapeFindings(method, config),
         ...detectLargeCollectionLoading(method),
         ...detectMissingProjection(method),
         ...detectRepeatedQueryPattern(method)
@@ -226241,6 +226390,7 @@ var import_node_fs25 = require("node:fs");
 var ts3 = __toESM(require_typescript());
 init_moduleDiscovery();
 init_archpilotIgnore();
+init_sourceScopeClassification();
 var ApplicationLayeringRuleIds = {
   CONTROLLER_BUSINESS_LOGIC: "AP-APP-001",
   REPOSITORY_BUSINESS_LOGIC: "AP-APP-002",
@@ -226912,35 +227062,30 @@ function isDbModelEvidenceToken(value) {
   const lower = normalized.toLowerCase();
   const excluded = /* @__PURE__ */ new Set([
     "a",
+    "all",
     "an",
-    "api",
-    "client",
-    "database",
-    "from",
-    "into",
-    "join",
-    "openapi",
-    "or",
-    "paddle",
-    "provider",
+    "doing",
+    "first",
+    "is",
+    "outside",
     "resend",
-    "s3",
-    "select",
-    "stripe",
+    "scratch",
     "swagger",
-    "table",
-    "the",
-    "this",
-    "to",
-    "update",
-    "where",
-    "with"
+    "the"
   ]);
   if (excluded.has(lower)) {
     return false;
   }
   return !/(?:client|provider|service|controller|guard|swagger|openapi)$/iu.test(normalized);
 }
+function isStructuredSqlTableEvidence(value, keyword, quote, following = "") {
+  const normalized = value.trim();
+  const hasStructuralEvidence = /^(?:from|update|into)$/iu.test(keyword) || quote !== void 0 && quote.length > 0 || /[_.]/u.test(normalized) || /^join$/iu.test(keyword) && /\bon\b/iu.test(following);
+  return hasStructuralEvidence && isDbModelEvidenceToken(normalized);
+}
+function extractSqlLikeLiterals(content) {
+  return [...content.matchAll(/(['"`])([\s\S]{0,1200}?)\1/gu)].map((match) => match[2] ?? "").filter((literal) => /\b(?:select|update|delete|insert)\b[\s\S]{0,400}\b(?:from|join|into|update)\b/iu.test(literal));
+}
 function extractDbModelsTouched(content) {
   const models = /* @__PURE__ */ new Set();
   for (const match of content.matchAll(/\b(?:this\.)?prisma\.([a-z]\w*)\./giu)) {
@@ -226948,9 +227093,13 @@ function extractDbModelsTouched(content) {
       models.add(match[1]);
     }
   }
-  for (const match of content.matchAll(/\b(?:from|join|update|into)\s+["`]?([A-Za-z_][\w]*)["`]?/giu)) {
-    if (match[1] && isDbModelEvidenceToken(match[1])) {
-      models.add(match[1]);
+  for (const sqlLiteral of extractSqlLikeLiterals(content)) {
+    for (const match of sqlLiteral.matchAll(/\b(?:from|join|update|into)\s+(["`]?)([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)?)\1/giu)) {
+      const keyword = /\b(from|join|update|into)\b/iu.exec(match[0])?.[1] ?? "";
+      const following = sqlLiteral.slice((match.index ?? 0) + match[0].length, (match.index ?? 0) + match[0].length + 120);
+      if (match[2] && isStructuredSqlTableEvidence(match[2], keyword, match[1], following)) {
+        models.add(match[2]);
+      }
     }
   }
   return sortUnique6(models).slice(0, 6);
@@ -227694,6 +227843,7 @@ var import_node_fs27 = require("node:fs");
 var ts5 = __toESM(require_typescript());
 init_moduleDiscovery();
 init_archpilotIgnore();
+init_sourceScopeClassification();
 var RuleIds2 = {
   TXN_BOUNDARY_TOO_BROAD: "AP-TXN-001",
   TXN_IN_CONTROLLER: "AP-TXN-002",
@@ -228737,35 +228887,30 @@ function isDbModelEvidenceToken2(value) {
   const lower = normalized.toLowerCase();
   const excluded = /* @__PURE__ */ new Set([
     "a",
+    "all",
     "an",
-    "api",
-    "client",
-    "database",
-    "from",
-    "into",
-    "join",
-    "openapi",
-    "or",
-    "paddle",
-    "provider",
+    "doing",
+    "first",
+    "is",
+    "outside",
     "resend",
-    "s3",
-    "select",
-    "stripe",
+    "scratch",
     "swagger",
-    "table",
-    "the",
-    "this",
-    "to",
-    "update",
-    "where",
-    "with"
+    "the"
   ]);
   if (excluded.has(lower)) {
     return false;
   }
   return !/(?:client|provider|service|controller|guard|swagger|openapi)$/iu.test(normalized);
 }
+function isStructuredSqlTableEvidence2(value, keyword, quote, following = "") {
+  const normalized = value.trim();
+  const hasStructuralEvidence = /^(?:from|update|into)$/iu.test(keyword) || quote !== void 0 && quote.length > 0 || /[_.]/u.test(normalized) || /^join$/iu.test(keyword) && /\bon\b/iu.test(following);
+  return hasStructuralEvidence && isDbModelEvidenceToken2(normalized);
+}
+function extractSqlLikeLiterals2(content) {
+  return [...content.matchAll(/(['"`])([\s\S]{0,1200}?)\1/gu)].map((match) => match[2] ?? "").filter((literal) => /\b(?:select|update|delete|insert)\b[\s\S]{0,400}\b(?:from|join|into|update)\b/iu.test(literal));
+}
 function extractDbModelsTouched2(content) {
   const models = /* @__PURE__ */ new Set();
   for (const match of content.matchAll(/\b(?:this\.)?prisma\.([a-z]\w*)\./giu)) {
@@ -228773,9 +228918,13 @@ function extractDbModelsTouched2(content) {
       models.add(match[1]);
     }
   }
-  for (const match of content.matchAll(/\b(?:from|join|update|into)\s+["`]?([A-Za-z_][\w]*)["`]?/giu)) {
-    if (match[1] && isDbModelEvidenceToken2(match[1])) {
-      models.add(match[1]);
+  for (const sqlLiteral of extractSqlLikeLiterals2(content)) {
+    for (const match of sqlLiteral.matchAll(/\b(?:from|join|update|into)\s+(["`]?)([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)?)\1/giu)) {
+      const keyword = /\b(from|join|update|into)\b/iu.exec(match[0])?.[1] ?? "";
+      const following = sqlLiteral.slice((match.index ?? 0) + match[0].length, (match.index ?? 0) + match[0].length + 120);
+      if (match[2] && isStructuredSqlTableEvidence2(match[2], keyword, match[1], following)) {
+        models.add(match[2]);
+      }
     }
   }
   return sortUnique7(models).slice(0, 6);
@@ -229025,6 +229174,7 @@ var path33 = __toESM(require("node:path"));
 var import_node_fs28 = require("node:fs");
 init_moduleDiscovery();
 init_archpilotIgnore();
+init_sourceScopeClassification();
 var RuleIds3 = {
   MISSING_PAGINATION: "AP-API-010",
   BULK_OPERATION_RISK: "AP-API-011",
@@ -229541,8 +229691,34 @@ function hasPaginationEvidence2(endpoint, contractEndpoints) {
 ${endpoint.signature}
 ${endpoint.body}`);
 }
+function stripStaticLiteralNoise(value) {
+  return value.replace(/\/\*[\s\S]*?\*\//gu, " ").replace(/\/\/.*$/gmu, " ").replace(/(['"`])(?:\\.|(?!\1)[\s\S])*\1/gu, '""');
+}
+function isStaticCollectionExpression(expression) {
+  const normalized = expression.trim().replace(/;$/u, "").trim();
+  return /^(?:Object\.)?(?:freeze|values|entries|keys)\s*\(/u.test(normalized) || /^(?:\[[\s\S]*\]|\{[\s\S]*\})$/u.test(normalized) || /^(?:[A-Z][A-Za-z0-9_]*|[a-z][A-Za-z0-9_]*(?:Config|Configs|Catalog|Catalogs|Metadata|Definitions|Types|Widgets|Constants))$/u.test(normalized);
+}
+function hasStaticDeclarationEvidence(fileContent, identifier) {
+  const escaped = identifier.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(`\\bimport\\s+(?:\\{[^}]*\\b${escaped}\\b[^}]*\\}|${escaped}\\b)`, "u").test(fileContent) || new RegExp(`\\b(?:const|readonly)\\s+${escaped}\\s*=\\s*(?:Object\\.freeze\\s*\\(|\\[|\\{)`, "u").test(fileContent) || new RegExp(`\\benum\\s+${escaped}\\b`, "u").test(fileContent);
+}
+function isStaticCollectionBackedEndpoint(endpoint) {
+  const body = endpoint.body.trim();
+  if (/\b(?:await|repository|Repository|createQueryBuilder|findMany|findAll|find\s*\(|query\s*\(|execute\s*\(|service\.)\b/iu.test(body)) {
+    return false;
+  }
+  const returnMatch = /\breturn\s+([\s\S]{0,500}?);/u.exec(body) ?? /\bres\.(?:json|send)\s*\(\s*([\s\S]{0,500}?)\s*\)\s*;?/u.exec(body) ?? /\bOk\s*\(\s*([\s\S]{0,500}?)\s*\)\s*;?/u.exec(body);
+  if (!returnMatch?.[1]) {
+    return false;
+  }
+  const expression = returnMatch[1].trim();
+  if (/^[A-Za-z_$][\w$]*$/u.test(expression)) {
+    return hasStaticDeclarationEvidence(endpoint.file.content, expression);
+  }
+  return isStaticCollectionExpression(stripStaticLiteralNoise(expression));
+}
 function detectPaginationFindings(endpoints, contractEndpoints) {
-  return endpoints.filter((endpoint) => isCollectionGet(endpoint) && !hasPaginationEvidence2(endpoint, contractEndpoints)).map((endpoint) => createFinding4({
+  return endpoints.filter((endpoint) => isCollectionGet(endpoint) && !hasPaginationEvidence2(endpoint, contractEndpoints) && !isStaticCollectionBackedEndpoint(endpoint)).map((endpoint) => createFinding4({
     id: RuleIds3.MISSING_PAGINATION,
     message: `Collection endpoint ${endpoint.httpMethod.toUpperCase()} ${endpoint.path} lacks visible pagination evidence.`,
     endpoint
@@ -231200,7 +231376,7 @@ src/
     architectureScope: "module",
     applicability: { requiresArchitectureModules: true },
     description: "Checks whether cross-module imports target another module through its public entrypoints rather than internal implementation files.",
-    recommendedFix: "Import another module through src/modules/<module>/index.ts or src/modules/<module>/public rather than reaching into internal files."
+    recommendedFix: "Import through the target module or package public entrypoint declared in its contract rather than reaching into internal implementation files."
   },
   DEP_CROSS_MODULE_DEPENDENCY_DECLARED_IN_CONTRACT: {
     id: ValidationRuleIds.DEP_CROSS_MODULE_DEPENDENCY_DECLARED_IN_CONTRACT,
@@ -242593,6 +242769,9 @@ var ignoredRootPathPrefixes = [
 function normalizeRelativePath5(value) {
   return value.replaceAll("\\", "/");
 }
+function isUnderJvmResourceRoot2(relativePath) {
+  return /(^|\/)src\/main\/resources(?:\/|$)/u.test(normalizeRelativePath5(relativePath).toLowerCase());
+}
 function sortUnique16(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
@@ -242730,7 +242909,7 @@ function collectDetectedRoots(scan) {
   const roots = /* @__PURE__ */ new Set();
   for (const manifestName of manifestFileNames) {
     for (const manifestPath of scan.manifestPathsByName[manifestName]) {
-      if (isIgnoredRelativePath(manifestPath)) {
+      if (isIgnoredRelativePath(manifestPath) || isUnderJvmResourceRoot2(manifestPath)) {
         continue;
       }
       const containingDirectory = normalizeRelativePath5(path58.dirname(manifestPath));
@@ -242745,11 +242924,11 @@ function buildResultFromScan(scan) {
   const evidence = [];
   const detectedRoots = collectDetectedRoots(scan);
   const filteredManifestPathsByName = {
-    "package.json": scan.manifestPathsByName["package.json"].filter((entry) => !isIgnoredRelativePath(entry)),
-    "pom.xml": scan.manifestPathsByName["pom.xml"].filter((entry) => !isIgnoredRelativePath(entry)),
-    "requirements.txt": scan.manifestPathsByName["requirements.txt"].filter((entry) => !isIgnoredRelativePath(entry)),
-    "go.mod": scan.manifestPathsByName["go.mod"].filter((entry) => !isIgnoredRelativePath(entry)),
-    "composer.json": scan.manifestPathsByName["composer.json"].filter((entry) => !isIgnoredRelativePath(entry))
+    "package.json": scan.manifestPathsByName["package.json"].filter((entry) => !isIgnoredRelativePath(entry) && !isUnderJvmResourceRoot2(entry)),
+    "pom.xml": scan.manifestPathsByName["pom.xml"].filter((entry) => !isIgnoredRelativePath(entry) && !isUnderJvmResourceRoot2(entry)),
+    "requirements.txt": scan.manifestPathsByName["requirements.txt"].filter((entry) => !isIgnoredRelativePath(entry) && !isUnderJvmResourceRoot2(entry)),
+    "go.mod": scan.manifestPathsByName["go.mod"].filter((entry) => !isIgnoredRelativePath(entry) && !isUnderJvmResourceRoot2(entry)),
+    "composer.json": scan.manifestPathsByName["composer.json"].filter((entry) => !isIgnoredRelativePath(entry) && !isUnderJvmResourceRoot2(entry))
   };
   let monorepoStrongSignals = 0;
   let monorepoWeakSignals = 0;
@@ -243049,6 +243228,12 @@ function confidenceWeight(confidence) {
   return 1;
 }
 function compareCandidates2(left, right) {
+  if (left.result.confidence === "high" && right.result.confidence === "high" && left.adapter.category === "framework" && right.adapter.category === "generic-language" && left.adapter.ecosystem === right.adapter.ecosystem) {
+    return -1;
+  }
+  if (left.result.confidence === "high" && right.result.confidence === "high" && left.adapter.category === "generic-language" && right.adapter.category === "framework" && left.adapter.ecosystem === right.adapter.ecosystem) {
+    return 1;
+  }
   const confidenceDiff = confidenceWeight(right.result.confidence) - confidenceWeight(left.result.confidence);
   if (confidenceDiff !== 0) {
     return confidenceDiff;
@@ -244794,6 +244979,9 @@ var ignoredDirectoryNames12 = /* @__PURE__ */ new Set([
 function normalizePath24(value) {
   return value.replaceAll("\\", "/");
 }
+function isUnderJvmResourceRoot3(relativePath) {
+  return /(^|\/)src\/main\/resources(?:\/|$)/u.test(normalizePath24(relativePath).toLowerCase());
+}
 function unique(values) {
   return [...new Set(values)];
 }
@@ -244942,7 +245130,7 @@ function hasAnyDependency2(summary, dependencyNames) {
 function collectCandidateRoots(workspaceRoot, topology, ignoreMatcher) {
   const roots = /* @__PURE__ */ new Set();
   for (const root of topology.detectedRoots ?? []) {
-    if (root && root !== "." && !isIgnoredPath6(ignoreMatcher, root) && !isSupportingAssetRoot(root)) {
+    if (root && root !== "." && !isIgnoredPath6(ignoreMatcher, root) && !isSupportingAssetRoot(root) && !isUnderJvmResourceRoot3(root)) {
       roots.add(normalizePath24(root));
     }
   }
@@ -244950,7 +245138,7 @@ function collectCandidateRoots(workspaceRoot, topology, ignoreMatcher) {
     const absoluteBase = path63.join(workspaceRoot, base);
     for (const entry of safeReadDirEntries4(absoluteBase)) {
       const relativePath = `${base}/${entry.name}`;
-      if (!entry.isDirectory() || ignoredDirectoryNames12.has(entry.name) || isIgnoredPath6(ignoreMatcher, relativePath) || isSupportingAssetRoot(relativePath) || (topology.detectedRoots?.length ?? 0) > 0 && !topology.detectedRoots?.includes(relativePath) && !hasManifest(workspaceRoot, relativePath)) {
+      if (!entry.isDirectory() || ignoredDirectoryNames12.has(entry.name) || isIgnoredPath6(ignoreMatcher, relativePath) || isSupportingAssetRoot(relativePath) || isUnderJvmResourceRoot3(relativePath) || (topology.detectedRoots?.length ?? 0) > 0 && !topology.detectedRoots?.includes(relativePath) && !hasManifest(workspaceRoot, relativePath)) {
         continue;
       }
       roots.add(relativePath);
@@ -245034,9 +245222,10 @@ function inspectRoot(workspaceRoot, root, ignoreMatcher) {
     addEvidence5(evidence, "Detected modules root");
   }
   const hasFrontendSignals = fileExists5(scan.files, "next.config.js") || fileExists5(scan.files, "next.config.ts") || fileExists5(scan.files, "angular.json") || fileExists5(scan.files, "vite.config.ts") || fileExists5(scan.files, "vite.config.js") || hasDirectory(scan.directories, "pages") || hasDirectory(scan.directories, "public") || hasAnyDependency2(packageJson, ["next", "react", "vue", "@angular/core"]);
+  const hasRunnableFrontendSignals = fileExists5(scan.files, "next.config.js") || fileExists5(scan.files, "next.config.ts") || fileExists5(scan.files, "angular.json") || fileExists5(scan.files, "vite.config.ts") || fileExists5(scan.files, "vite.config.js") || fileExists5(scan.files, "index.html") || hasDirectory(scan.directories, "pages") || hasDirectory(scan.directories, "src/app");
   const hasBackendSignals = hasApiBoundary || hasDatabaseAccess || fileExists5(scan.files, "pom.xml") || fileExists5(scan.files, "requirements.txt") || fileExists5(scan.files, "go.mod") || hasDirectory(scan.directories, "src/main/java");
   let classification = "unknown";
-  if ((root.startsWith("packages/") || root.startsWith("libs/")) && !hasApiBoundary) {
+  if ((root.startsWith("packages/") || root.startsWith("libs/")) && !hasRunnableFrontendSignals && !hasApiBoundary) {
     classification = "shared_package";
   } else if (hasBackendSignals && !hasFrontendSignals) {
     classification = "backend_app";
@@ -245147,6 +245336,8 @@ function isIgnoredComponentCandidatePath(componentPath) {
   const ignoredRootSegments = [
     "tests",
     "test",
+    "cypress",
+    "cypress-tests",
     "__tests__",
     "fixtures",
     "smoke",
@@ -245214,8 +245405,14 @@ function recordKeys(value) {
 function hasObject(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
+function hasPackagePublishSurface(packageJson) {
+  return hasObject(packageJson?.exports) || typeof packageJson?.main === "string" || typeof packageJson?.module === "string" || typeof packageJson?.types === "string" || hasObject(packageJson?.publishConfig) || Array.isArray(packageJson?.files);
+}
+function absoluteComponentRoot(workspaceRoot, componentPath) {
+  return componentPath === "." ? workspaceRoot : path64.join(workspaceRoot, ...componentPath.split("/"));
+}
 function readPackageJson(workspaceRoot, componentPath) {
-  const absoluteRoot = componentPath === "." ? workspaceRoot : path64.join(workspaceRoot, ...componentPath.split("/"));
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
   return safeReadJson(path64.join(absoluteRoot, "package.json"));
 }
 function readTextFileSafe(filePath) {
@@ -245233,7 +245430,10 @@ function readFirstXmlTag(value, tagName) {
   return match?.[1]?.trim().replace(/\s+/gu, " ");
 }
 function readMavenMetadata(workspaceRoot, componentPath) {
-  const absoluteRoot = componentPath === "." ? workspaceRoot : path64.join(workspaceRoot, ...componentPath.split("/"));
+  if (isUnderJvmResourceRoot4(componentPath)) {
+    return void 0;
+  }
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
   const pomXml = readTextFileSafe(path64.join(absoluteRoot, "pom.xml"));
   if (!pomXml) {
     return void 0;
@@ -245329,21 +245529,86 @@ function resolveId(componentPath, usedIds) {
   usedIds.add(id);
   return id;
 }
-function resolveKind(candidate, localProjectKinds) {
+function hasRunnableFrontendComponentEvidence(workspaceRoot, componentPath) {
+  const absoluteRoot = componentPath === "." ? workspaceRoot : path64.join(workspaceRoot, ...componentPath.split("/"));
+  const packageJson = readPackageJson(workspaceRoot, componentPath);
+  const dependencies = [
+    ...recordKeys(packageJson?.dependencies),
+    ...recordKeys(packageJson?.devDependencies)
+  ];
+  const scripts = recordKeys(packageJson?.scripts);
+  const hasFrontendFramework = dependencies.some(
+    (dependency) => /^(?:react|next|vue|@angular\/core|@sveltejs\/kit)$/u.test(dependency)
+  );
+  const hasInteractiveRunnableScript = scripts.some(
+    (script) => /^(?:dev|start|serve|preview)(?::|$)/u.test(script)
+  );
+  const hasBundlerConfig = [
+    "next.config.js",
+    "next.config.ts",
+    "vite.config.js",
+    "vite.config.ts",
+    "angular.json"
+  ].some((relativePath) => pathExists19(path64.join(absoluteRoot, ...relativePath.split("/"))));
+  const hasApplicationEntry = [
+    "index.html",
+    "src/main.tsx",
+    "src/main.ts",
+    "src/App.tsx",
+    "src/app",
+    "pages"
+  ].some((relativePath) => pathExists19(path64.join(absoluteRoot, ...relativePath.split("/"))));
+  return hasFrontendFramework && (hasApplicationEntry || hasInteractiveRunnableScript && hasBundlerConfig);
+}
+function isUnderJvmResourceRoot4(componentPath) {
+  return /(^|\/)src\/main\/resources(?:\/|$)/u.test(normalizePath25(componentPath).toLowerCase());
+}
+function hasRuntimeSourceFiles(workspaceRoot, componentPath) {
+  if (isUnderJvmResourceRoot4(componentPath)) {
+    return false;
+  }
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
+  const sourceRoots = [
+    path64.join(absoluteRoot, "src", "main", "java"),
+    path64.join(absoluteRoot, "src"),
+    path64.join(absoluteRoot, "app"),
+    path64.join(absoluteRoot, "server")
+  ];
+  for (const sourceRoot of sourceRoots) {
+    if (!pathExists19(sourceRoot)) {
+      continue;
+    }
+    const entries = fs58.readdirSync(sourceRoot, { recursive: true, withFileTypes: true });
+    if (entries.some((entry) => entry.isFile() && /\.(?:ts|tsx|js|jsx|java|cs|py|php|go)$/iu.test(entry.name))) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveKind(workspaceRoot, candidate, localProjectKinds) {
   const lowerPath = candidate.path.toLowerCase();
+  const packageJson = readPackageJson(workspaceRoot, candidate.path);
+  const hasRunnableFrontendEvidence = hasRunnableFrontendComponentEvidence(workspaceRoot, candidate.path);
+  const hasPublishSurface = hasPackagePublishSurface(packageJson);
   if (lowerPath.endsWith("/db") || lowerPath.endsWith("/database") || lowerPath.endsWith("/data")) {
     return "data";
   }
   const classification = candidate.architectureRoot?.classification;
   if (classification === "frontend_app") {
-    return "frontend";
+    return hasPublishSurface && !hasRunnableFrontendEvidence ? "library" : "frontend";
   }
   if (classification === "backend_app") {
     return "backend";
   }
+  if (hasRunnableFrontendEvidence && localProjectKinds.primaryKind !== "backend" && localProjectKinds.primaryKind !== "service" && localProjectKinds.primaryKind !== "cli") {
+    return "frontend";
+  }
   if (classification === "shared_package") {
     return "library";
   }
+  if (hasPublishSurface && !hasRunnableFrontendEvidence) {
+    return "library";
+  }
   if (localProjectKinds.primaryKind === "service") {
     return "worker";
   }
@@ -245412,10 +245677,11 @@ function classifyGovernanceRole(input2) {
   const scriptText = scripts.join(" ").toLowerCase();
   const dependencyText = [...dependencies, ...devDependencies].join(" ").toLowerCase();
   const hasStrongSupportPath = hasAnyToken(pathText, [
-    /(^|\/)(testing|test-plugins|fixtures?|examples?|benchmarks?|smoke)(\/|$)/u,
+    /(^|\/)(testing|test-plugins|cypress-tests|fixtures?|examples?|benchmarks?|smoke)(\/|$)/u,
     /(^|\/)(dev-server|scaffold|scaffolding|generators?|devkit|tooling|tools)(\/|$)/u
   ]);
-  const hasPublishSurface = hasObject(packageJson?.exports) || typeof packageJson?.main === "string" || typeof packageJson?.module === "string" || typeof packageJson?.types === "string" || hasObject(packageJson?.publishConfig) || Array.isArray(packageJson?.files);
+  const isPlainResourcesSurface = isUnderJvmResourceRoot4(pathText) && !hasRuntimeSourceFiles(input2.workspaceRoot, input2.candidate.path) && !packageJson && !maven;
+  const hasPublishSurface = hasPackagePublishSurface(packageJson);
   const isPrivate = packageJson?.private === true;
   const hasBin = hasObject(packageJson?.bin) || typeof packageJson?.bin === "string";
   const mavenMetadataText = `${maven?.artifactId ?? ""} ${maven?.name ?? ""}`.toLowerCase();
@@ -245484,7 +245750,7 @@ function classifyGovernanceRole(input2) {
     addEvidence6(evidence, "Package metadata describes development/tooling usage");
   }
   if (hasAnyToken(pathText, [
-    /(^|\/)(test|tests|testing|__tests__|fixtures?|examples?|benchmarks?|smoke)(\/|$)/u,
+    /(^|\/)(test|tests|testing|__tests__|cypress|cypress-tests|fixtures?|examples?|benchmarks?|smoke)(\/|$)/u,
     /(^|\/)(dev-server|test-plugins|scaffold|scaffolding|generators?|devkit|tooling|tools)(\/|$)/u
   ])) {
     supportScore += 1;
@@ -245534,6 +245800,17 @@ function classifyGovernanceRole(input2) {
     supportScore += 1;
     addEvidence6(evidence, "Maven POM-only aggregator/packaging module");
   }
+  if (isPlainResourcesSurface) {
+    supportScore += 4;
+    addEvidence6(evidence, "Resources-only surface without runtime source or manifest evidence");
+  }
+  if (isPlainResourcesSurface && input2.kind !== "infrastructure" && input2.stack !== "terraform" && input2.stack !== "ansible") {
+    return {
+      governanceRole: "support",
+      governanceEvidence: uniqueSorted4(evidence),
+      selectedByDefault: false
+    };
+  }
   if (hasMavenDistributionPackagingEvidence && hasAnyToken(mavenMetadataText, [/\b(docs?|documentation|metadata tests?|licenses?|maven plugins?|builds?)\b/u])) {
     supportScore += 3;
     addEvidence6(evidence, "Maven documentation/build/distribution packaging evidence without runtime source");
@@ -245547,9 +245824,9 @@ function classifyGovernanceRole(input2) {
   }
   if (maven && (isMavenPomOnly || hasMavenDistributionPackagingEvidence) && supportScore >= 1) {
     return {
-      governanceRole: "ambiguous",
+      governanceRole: "support",
       governanceEvidence: uniqueSorted4(evidence),
-      selectedByDefault: true
+      selectedByDefault: false
     };
   }
   if (runtimeScore >= 2) {
@@ -245590,8 +245867,10 @@ function maybeAddAttributedApiAndDb(component, workspaceRoot, componentPath, arc
 }
 function detectComponents(input2) {
   const ignoreMatcher = input2.ignoreMatcher ?? loadArchpilotIgnoreMatcher(input2.workspaceRoot);
-  const manifestBackedRoots = new Set(input2.topology.detectedRoots ?? []);
-  const rootCandidates = buildRootCandidates(input2).filter((candidate) => !ignoreMatcher.isIgnored(candidate.path)).filter((candidate) => !isIgnoredComponentCandidatePath(candidate.path)).filter((candidate) => {
+  const manifestBackedRoots = new Set(
+    (input2.topology.detectedRoots ?? []).filter((root) => !isUnderJvmResourceRoot4(root))
+  );
+  const rootCandidates = buildRootCandidates(input2).filter((candidate) => !ignoreMatcher.isIgnored(candidate.path)).filter((candidate) => !isIgnoredComponentCandidatePath(candidate.path)).filter((candidate) => !(isUnderJvmResourceRoot4(candidate.path) && !hasRuntimeSourceFiles(input2.workspaceRoot, candidate.path))).filter((candidate) => {
     if (input2.topology.topology !== "monorepo" || manifestBackedRoots.size === 0) {
       return true;
     }
@@ -245614,7 +245893,7 @@ function detectComponents(input2) {
     }
     const localProjectKinds = input2.runContext?.detectProjectKinds(absoluteRoot) ?? detectProjectKinds(absoluteRoot);
     const stackDetection = input2.runContext?.detectStacks(absoluteRoot) ?? detectStacks(absoluteRoot);
-    const kind = resolveKind(candidate, localProjectKinds);
+    const kind = resolveKind(input2.workspaceRoot, candidate, localProjectKinds);
     const stack = resolveStack(kind, stackDetection);
     const evidence = [...candidate.evidence];
     if (candidate.architectureRoot?.classification && candidate.architectureRoot.classification !== "unknown") {
@@ -245851,6 +246130,10 @@ function getSelectedCandidate(detection) {
 function getBackendComponents(detection) {
   return (detection.detectedComponents ?? []).filter((component) => component.kind === "backend" || component.kind === "worker");
 }
+function getDefaultGovernedBackendComponents(detection) {
+  const components = detection.detectedComponents ?? [];
+  return components.filter((component) => component.kind === "backend" || component.kind === "worker").filter((component) => isDefaultGovernedComponent(component, components));
+}
 function getFrontendComponents(detection) {
   return (detection.detectedComponents ?? []).filter((component) => component.kind === "frontend");
 }
@@ -245990,7 +246273,8 @@ function resolveProposalComponents(detection) {
   return components.length > 0 ? components : void 0;
 }
 function resolveResourceOwnerComponent(detection) {
-  return getBackendComponents(detection).find((component) => component.kind === "backend") ?? getBackendComponents(detection)[0];
+  const backendComponents = getDefaultGovernedBackendComponents(detection);
+  return backendComponents.find((component) => component.kind === "backend") ?? backendComponents[0];
 }
 function resourceIdFor(ownerId, suffix) {
   if (suffix === "api" && /(^|-)api$/u.test(ownerId)) {
@@ -246025,7 +246309,7 @@ function resolveProposalResources(input2) {
     usedIds.add(resource.id);
     resources.push(resource);
   };
-  for (const component of getBackendComponents(input2.detection)) {
+  for (const component of getDefaultGovernedBackendComponents(input2.detection)) {
     if (component.apiStyle && component.apiStyle !== "unknown" && component.apiStyle !== "none") {
       addResource({
         id: resourceIdFor(component.id, "api"),