@archpilotlabs/archpilot 0.2.1 → 0.2.3

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();
@@ -215175,9 +215175,9 @@ function pathHasFileExtension(value) {
 function isRelativeImport(importSpecifier) {
   return importSpecifier === "." || importSpecifier === ".." || importSpecifier.startsWith("./") || importSpecifier.startsWith("../");
 }
-function isPathInsideOrEqual(childPath, parentPath) {
-  const child = normalizePath2(childPath).toLowerCase();
-  const parent = normalizePath2(parentPath).toLowerCase();
+function isNormalizedPathInsideOrEqual(normalizedChildPath, normalizedParentPath) {
+  const child = normalizedChildPath.toLowerCase();
+  const parent = normalizedParentPath.toLowerCase();
   return child === parent || child.startsWith(`${parent}/`);
 }
 function toEndpoint(candidate) {
@@ -215196,38 +215196,43 @@ function compareCandidates(left, right) {
   }
   return left.component.id.localeCompare(right.component.id);
 }
-function modulePathMatchScore(inputPath, modulePath) {
-  const normalizedModulePath = normalizePath2(modulePath);
+function normalizedModulePathMatchScore(normalizedInputPath, normalizedModulePath) {
   if (pathHasFileExtension(normalizedModulePath)) {
-    return isPathInsideOrEqual(inputPath, normalizedModulePath) || isPathInsideOrEqual(normalizedModulePath, inputPath) ? normalizedModulePath.length + 1e3 : void 0;
+    return isNormalizedPathInsideOrEqual(normalizedInputPath, normalizedModulePath) || isNormalizedPathInsideOrEqual(normalizedModulePath, normalizedInputPath) ? normalizedModulePath.length + 1e3 : void 0;
   }
-  return isPathInsideOrEqual(inputPath, normalizedModulePath) ? normalizedModulePath.length + 1e3 : void 0;
+  return isNormalizedPathInsideOrEqual(normalizedInputPath, normalizedModulePath) ? normalizedModulePath.length + 1e3 : void 0;
+}
+function modulePathMatchScore(inputPath, modulePath) {
+  return normalizedModulePathMatchScore(normalizePath2(inputPath), normalizePath2(modulePath));
 }
 function findComponentForPath(components, inputPath) {
   const normalizedInputPath = normalizePath2(inputPath);
   const candidates = [];
   for (const component of components) {
-    for (const [moduleId, moduleReference] of Object.entries(component.modules)) {
-      if (!moduleReference.path) {
+    for (const moduleReference of component.modules) {
+      if (!moduleReference.normalizedPath) {
         continue;
       }
-      const score = modulePathMatchScore(normalizedInputPath, moduleReference.path);
+      const score = normalizedModulePathMatchScore(
+        normalizedInputPath,
+        moduleReference.normalizedPath
+      );
       if (score !== void 0) {
         candidates.push({
-          component,
-          moduleId,
+          component: component.component,
+          moduleId: moduleReference.moduleId,
           path: moduleReference.path,
           ownership: "module-path",
           score
         });
       }
     }
-    if (component.path && isPathInsideOrEqual(normalizedInputPath, component.path)) {
+    if (component.normalizedPath && isNormalizedPathInsideOrEqual(normalizedInputPath, component.normalizedPath)) {
       candidates.push({
-        component,
-        path: component.path,
+        component: component.component,
+        path: component.component.path,
         ownership: "component-path",
-        score: normalizePath2(component.path).length
+        score: component.normalizedPath.length
       });
     }
   }
@@ -215238,19 +215243,20 @@ function findComponentForModuleSpecifier(components, importSpecifier) {
   const normalizedSegments = normalizedImport.split("/").filter((segment) => segment.length > 0);
   const candidates = [];
   for (const component of components) {
-    for (const [moduleId, moduleReference] of Object.entries(component.modules)) {
+    for (const moduleReference of component.modules) {
+      const moduleId = moduleReference.moduleId;
       if (normalizedImport === moduleId || normalizedImport.startsWith(`${moduleId}/`)) {
         candidates.push({
-          component,
+          component: component.component,
           moduleId,
           ...moduleReference.path ? { path: moduleReference.path } : {},
           ownership: moduleReference.path ? "module-path" : "component-path",
           score: moduleId.length + 500
         });
       }
-      if (component.id === VIRTUAL_WORKSPACE_COMPONENT_ID && normalizedSegments.includes(moduleId)) {
+      if (component.component.id === VIRTUAL_WORKSPACE_COMPONENT_ID && normalizedSegments.includes(moduleId)) {
         candidates.push({
-          component,
+          component: component.component,
           moduleId,
           ...moduleReference.path ? { path: moduleReference.path } : {},
           ownership: "virtual-workspace",
@@ -215258,20 +215264,20 @@ function findComponentForModuleSpecifier(components, importSpecifier) {
         });
       }
     }
-    if (component.path && isPathInsideOrEqual(normalizedImport, component.path)) {
+    if (component.normalizedPath && isNormalizedPathInsideOrEqual(normalizedImport, component.normalizedPath)) {
       candidates.push({
-        component,
-        path: component.path,
+        component: component.component,
+        path: component.component.path,
         ownership: "component-path",
-        score: normalizePath2(component.path).length
+        score: component.normalizedPath.length
       });
     }
-    if (normalizedImport === component.id || normalizedImport.startsWith(`${component.id}/`)) {
+    if (normalizedImport === component.component.id || normalizedImport.startsWith(`${component.component.id}/`)) {
       candidates.push({
-        component,
-        ...component.path ? { path: component.path } : {},
-        ownership: component.path ? "component-path" : "virtual-workspace",
-        score: component.id.length
+        component: component.component,
+        ...component.component.path ? { path: component.component.path } : {},
+        ownership: component.component.path ? "component-path" : "virtual-workspace",
+        score: component.component.id.length
       });
     }
   }
@@ -215315,12 +215321,12 @@ function resolveSourceCandidate(contract, components, sourceFile) {
     return directMatch;
   }
   const virtualComponent = components.find(
-    (component) => component.id === VIRTUAL_WORKSPACE_COMPONENT_ID
-  );
+    (component) => component.component.id === VIRTUAL_WORKSPACE_COMPONENT_ID
+  )?.component;
   if (virtualComponent) {
     return resolveLegacyVirtualSource(contract, sourceFile, virtualComponent);
   }
-  const fallback = [...components].sort((left, right) => left.id.localeCompare(right.id))[0];
+  const fallback = [...components].map((component) => component.component).sort((left, right) => left.id.localeCompare(right.id))[0];
   if (fallback) {
     return {
       component: fallback,
@@ -215331,7 +215337,7 @@ function resolveSourceCandidate(contract, components, sourceFile) {
   }
   throw new Error("Architecture dependency context requires at least one normalized component.");
 }
-function resolveTargetCandidate(components, sourceFile, importSpecifier) {
+function resolveTargetCandidate(contract, components, sourceFile, importSpecifier) {
   if (isRelativeImport(importSpecifier)) {
     const resolvedTargetPath = resolveRelativeImportPath(sourceFile, importSpecifier);
     return {
@@ -215340,7 +215346,8 @@ function resolveTargetCandidate(components, sourceFile, importSpecifier) {
     };
   }
   const normalizedImport = normalizeImportPath(importSpecifier);
-  if (normalizedImport.startsWith("src/") || normalizedImport.startsWith("apps/") || normalizedImport.startsWith("services/") || normalizedImport.startsWith("packages/") || normalizedImport.startsWith("libs/") || normalizedImport.startsWith("libraries/") || normalizedImport.startsWith("workers/")) {
+  const normalizedModulesRoot = normalizePath2(resolveModulesRootFromContract(contract));
+  if (normalizedModulesRoot.length > 0 && normalizedImport.startsWith(`${normalizedModulesRoot}/`) || normalizedImport.startsWith("src/") || normalizedImport.startsWith("app/") || normalizedImport.startsWith("apps/") || normalizedImport.startsWith("services/") || normalizedImport.startsWith("packages/") || normalizedImport.startsWith("libs/") || normalizedImport.startsWith("libraries/") || normalizedImport.startsWith("workers/")) {
     return {
       candidate: findComponentForPath(components, normalizedImport),
       resolvedTargetPath: normalizedImport
@@ -215352,20 +215359,28 @@ function resolveTargetCandidate(components, sourceFile, importSpecifier) {
   }
   return {};
 }
-function resolveDependencyContext(contract, input2) {
-  const model = normalizeArchitectureWorkspaceModel(contract);
-  const sourceCandidate = resolveSourceCandidate(contract, model.components, input2.sourceFile);
+function prepareComponentReferences(components) {
+  return components.map((component) => ({
+    component,
+    ...component.path ? { normalizedPath: normalizePath2(component.path) } : {},
+    modules: Object.entries(component.modules).map(([moduleId, moduleReference]) => ({
+      moduleId,
+      ...moduleReference.path ? {
+        path: moduleReference.path,
+        normalizedPath: normalizePath2(moduleReference.path)
+      } : {}
+    }))
+  }));
+}
+function resolveDependencyContextWithPreparedComponents(contract, components, input2) {
+  const sourceCandidate = resolveSourceCandidate(contract, components, input2.sourceFile);
   const { candidate: resolvedTargetCandidate, resolvedTargetPath } = resolveTargetCandidate(
-    model.components,
+    contract,
+    components,
     input2.sourceFile,
     input2.importSpecifier
   );
-  const targetCandidate = resolvedTargetCandidate ?? (resolvedTargetPath ? {
-    ...sourceCandidate,
-    path: resolvedTargetPath,
-    ownership: sourceCandidate.ownership,
-    score: 0
-  } : void 0);
+  const targetCandidate = resolvedTargetCandidate ?? (resolvedTargetPath ? resolveSourceCandidate(contract, components, resolvedTargetPath) : void 0);
   if (!targetCandidate) {
     return {
       dependencyType: "external",
@@ -215386,6 +215401,19 @@ function resolveDependencyContext(contract, input2) {
     isExternal: false
   };
 }
+function createArchitectureDependencyContextResolver(contract) {
+  const model = normalizeArchitectureWorkspaceModel(contract);
+  const components = prepareComponentReferences(model.components);
+  return {
+    contract,
+    model,
+    resolve: (input2) => resolveDependencyContextWithPreparedComponents(
+      contract,
+      components,
+      input2
+    )
+  };
+}
 var path6;
 var init_architectureDependencyContext = __esm({
   "../core/src/architectureDependencyContext.ts"() {
@@ -215396,17 +215424,85 @@ 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) {
+function isPathInsideOrEqual(childPath, parentPath) {
   const child = normalizeAbsolutePath(childPath);
   const parent = normalizeAbsolutePath(parentPath);
   return child === parent || child.startsWith(`${parent}/`);
@@ -215442,7 +215538,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;
     }
@@ -215487,6 +215583,9 @@ function buildChildModulesByParent(hierarchyEdges) {
     ])
   );
 }
+function isIsolatedContractlessHierarchyModule(input2) {
+  return !input2.hasContract && input2.parentModule !== void 0 && input2.declaredDependencies.length === 0 && input2.actualDependencies.length === 0 && input2.inboundDeclaredFrom.length === 0 && input2.inboundActualFrom.length === 0 && input2.unusedDeclaredDependencies.length === 0 && input2.undeclaredActualDependencies.length === 0;
+}
 function getScriptKind(filePath) {
   const extension = path7.extname(filePath).toLowerCase();
   switch (extension) {
@@ -215642,9 +215741,9 @@ 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];
+      const moduleEntry = [...moduleRoots.entries()].filter(([, moduleRoot2]) => isPathInsideOrEqual(absoluteTarget, moduleRoot2)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
       if (!moduleEntry) {
         continue;
       }
@@ -215745,7 +215844,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 +215952,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 +215968,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 });
@@ -215883,11 +215978,11 @@ async function collectSourceFiles(directoryPath, adapter, scanRootPath = directo
     const fullPath = path7.join(directoryPath, entry.name);
     if (entry.isDirectory()) {
       if (excludedDirectoryRoots.some(
-        (excludedRoot) => isPathInsideOrEqual2(fullPath, excludedRoot)
+        (excludedRoot) => isPathInsideOrEqual(fullPath, excludedRoot)
       )) {
         continue;
       }
-      const normalizedRelativeDirectory = normalizePath3(
+      const normalizedRelativeDirectory = normalizePath4(
         path7.relative(scanRootPath, fullPath)
       );
       if (adapter.ignoreDirectoryNames.includes(entry.name) || adapter.ignoreDirectoryNames.includes(normalizedRelativeDirectory)) {
@@ -216098,6 +216193,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 && isPathInsideOrEqual(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 +216369,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 +216707,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,
@@ -216638,22 +216811,22 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   if (!resolvedPath) {
     return void 0;
   }
-  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];
+  const targetModuleEntry = packageAliasTargetModule && packageAliasTargetModuleRoot ? [packageAliasTargetModule, packageAliasTargetModuleRoot] : [...moduleRoots.entries()].filter(([, moduleRoot]) => isPathInsideOrEqual(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 +216842,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,10 +216853,11 @@ 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)
   )) {
-    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleName && isPathInsideOrEqual2(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
+    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleName && isPathInsideOrEqual(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
     const sourceFiles = await collectSourceFiles(
       moduleRoot,
       adapter,
@@ -216691,7 +216865,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 +216890,7 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
           sourceFilePath,
           importReference.specifier,
           adapter,
+          javaImportIndex,
           options?.resolutionContext
         );
         if (!resolved || resolved.targetModule === moduleName) {
@@ -216818,15 +216993,15 @@ function toDependencyContextMetadata(context) {
     isExternal: context.isExternal
   };
 }
-function resolveImportDependencyContextMetadata(architectureContract, dependencyImport) {
-  const directContext = resolveDependencyContext(architectureContract, {
+function resolveImportDependencyContextMetadata(architectureContract, dependencyImport, resolver = createArchitectureDependencyContextResolver(architectureContract)) {
+  const directContext = resolver.resolve({
     sourceFile: dependencyImport.sourceFileRelativePath,
     importSpecifier: dependencyImport.importSpecifier
   });
   if (!directContext.isExternal) {
     return toDependencyContextMetadata(directContext);
   }
-  const moduleTargetContext = resolveDependencyContext(architectureContract, {
+  const moduleTargetContext = resolver.resolve({
     sourceFile: dependencyImport.sourceFileRelativePath,
     importSpecifier: dependencyImport.targetModule
   });
@@ -216837,7 +217012,7 @@ function resolveImportDependencyContextMetadata(architectureContract, dependency
       resolvedTargetPath: dependencyImport.resolvedTargetRelativePath
     });
   }
-  const resolvedPathContext = resolveDependencyContext(architectureContract, {
+  const resolvedPathContext = resolver.resolve({
     sourceFile: dependencyImport.sourceFileRelativePath,
     importSpecifier: dependencyImport.resolvedTargetRelativePath
   });
@@ -216875,11 +217050,15 @@ function validateComponentDependencyPolicies(architectureContract, imports) {
   if (!architectureContract || policies.size === 0) {
     return [];
   }
+  const dependencyContextResolver = createArchitectureDependencyContextResolver(
+    architectureContract
+  );
   const findings = [];
   for (const dependencyImport of imports) {
     const dependencyMetadata = resolveImportDependencyContextMetadata(
       architectureContract,
-      dependencyImport
+      dependencyImport,
+      dependencyContextResolver
     );
     if (dependencyMetadata.dependencyType !== "cross-component" || dependencyMetadata.isExternal || !dependencyMetadata.sourceComponentId || !dependencyMetadata.targetComponentId) {
       continue;
@@ -216915,7 +217094,7 @@ function validateComponentDependencyPolicies(architectureContract, imports) {
   }
   return findings;
 }
-function isModuleScopedDependencyImport(architectureContract, dependencyImport) {
+function isModuleScopedDependencyImport(architectureContract, dependencyImport, resolver) {
   if (dependencyImport.sourceModule === dependencyImport.targetModule || isParentChildModuleRelationship(
     dependencyImport.sourceModule,
     dependencyImport.targetModule
@@ -216927,7 +217106,8 @@ function isModuleScopedDependencyImport(architectureContract, dependencyImport)
   }
   const dependencyMetadata = resolveImportDependencyContextMetadata(
     architectureContract,
-    dependencyImport
+    dependencyImport,
+    resolver
   );
   return !dependencyMetadata.isExternal;
 }
@@ -216956,7 +217136,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 +217239,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 +217286,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 +217306,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 +217335,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.";
 }
@@ -217273,34 +217457,42 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
   const inboundDeclared = buildInboundDependencyMap(declaredBySource, moduleIds);
   const inboundActual = buildInboundDependencyMap(actualBySource, moduleIds);
   const hierarchyEdges = buildModuleHierarchyEdges(moduleIds);
-  const childModulesByParent = buildChildModulesByParent(hierarchyEdges);
   const parentModuleByChild = new Map(
     hierarchyEdges.map((edge) => [edge.childModule, edge.parentModule])
   );
+  const moduleSummaries = moduleIds.map((moduleId) => {
+    const declaredDependencies = sortUnique2(declaredBySource.get(moduleId) ?? []);
+    const actualDependencies = sortUnique2(actualBySource.get(moduleId) ?? []);
+    const unusedDeclaredDependencies = declaredDependencies.filter(
+      (declaredDependency) => !actualDependencies.includes(declaredDependency)
+    );
+    const undeclaredActualDependencies = actualDependencies.filter(
+      (actualDependency) => !declaredDependencies.includes(actualDependency)
+    );
+    return {
+      module: moduleId,
+      hasContract: hasContractByModule.get(moduleId) ?? false,
+      ...parentModuleByChild.has(moduleId) ? { parentModule: parentModuleByChild.get(moduleId) } : {},
+      childModules: [],
+      declaredDependencies,
+      actualDependencies,
+      inboundDeclaredFrom: inboundDeclared.get(moduleId) ?? [],
+      inboundActualFrom: inboundActual.get(moduleId) ?? [],
+      unusedDeclaredDependencies,
+      undeclaredActualDependencies
+    };
+  }).filter((moduleSummary) => !isIsolatedContractlessHierarchyModule(moduleSummary));
+  const retainedModuleIds = new Set(moduleSummaries.map((moduleSummary) => moduleSummary.module));
+  const retainedHierarchyEdges = hierarchyEdges.filter(
+    (edge) => retainedModuleIds.has(edge.parentModule) && retainedModuleIds.has(edge.childModule)
+  );
+  const childModulesByParent = buildChildModulesByParent(retainedHierarchyEdges);
   return {
-    modules: moduleIds.map((moduleId) => {
-      const declaredDependencies = sortUnique2(declaredBySource.get(moduleId) ?? []);
-      const actualDependencies = sortUnique2(actualBySource.get(moduleId) ?? []);
-      const unusedDeclaredDependencies = declaredDependencies.filter(
-        (declaredDependency) => !actualDependencies.includes(declaredDependency)
-      );
-      const undeclaredActualDependencies = actualDependencies.filter(
-        (actualDependency) => !declaredDependencies.includes(actualDependency)
-      );
-      return {
-        module: moduleId,
-        hasContract: hasContractByModule.get(moduleId) ?? false,
-        ...parentModuleByChild.has(moduleId) ? { parentModule: parentModuleByChild.get(moduleId) } : {},
-        childModules: childModulesByParent.get(moduleId) ?? [],
-        declaredDependencies,
-        actualDependencies,
-        inboundDeclaredFrom: inboundDeclared.get(moduleId) ?? [],
-        inboundActualFrom: inboundActual.get(moduleId) ?? [],
-        unusedDeclaredDependencies,
-        undeclaredActualDependencies
-      };
-    }),
-    hierarchyEdges
+    modules: moduleSummaries.map((moduleSummary) => ({
+      ...moduleSummary,
+      childModules: childModulesByParent.get(moduleSummary.module) ?? []
+    })),
+    hierarchyEdges: retainedHierarchyEdges
   };
 }
 async function validateDependencyContractBoundaries(workspaceRoot, architectureContract, options) {
@@ -217330,9 +217522,16 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     workspacePackageAliases,
     adapter
   );
+  const dependencyContextResolver = createArchitectureDependencyContextResolver(
+    architectureContract
+  );
   const peerImports = filterPeerModuleImports(imports);
   const moduleScopedPeerImports = peerImports.filter(
-    (dependencyImport) => isModuleScopedDependencyImport(architectureContract, dependencyImport)
+    (dependencyImport) => isModuleScopedDependencyImport(
+      architectureContract,
+      dependencyImport,
+      dependencyContextResolver
+    )
   );
   const findings = [];
   const moduleContractCache = /* @__PURE__ */ new Map();
@@ -217342,7 +217541,8 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     for (const dependencyImport of moduleScopedPeerImports) {
       const dependencyMetadata = resolveImportDependencyContextMetadata(
         architectureContract,
-        dependencyImport
+        dependencyImport,
+        dependencyContextResolver
       );
       if (dependencyMetadata.isExternal) {
         continue;
@@ -217474,7 +217674,8 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     for (const dependencyImport of moduleScopedPeerImports) {
       const dependencyMetadata = resolveImportDependencyContextMetadata(
         architectureContract,
-        dependencyImport
+        dependencyImport,
+        dependencyContextResolver
       );
       if (dependencyMetadata.isExternal) {
         continue;
@@ -217548,12 +217749,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;
@@ -217732,11 +217934,17 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
     workspacePackageAliases,
     adapter
   );
+  const dependencyContextResolver = parsedArchitectureContract ? createArchitectureDependencyContextResolver(parsedArchitectureContract) : void 0;
   const peerImports = filterPeerModuleImports(imports);
   const moduleScopedPeerImports = peerImports.filter(
-    (dependencyImport) => isModuleScopedDependencyImport(parsedArchitectureContract, dependencyImport)
+    (dependencyImport) => isModuleScopedDependencyImport(
+      parsedArchitectureContract,
+      dependencyImport,
+      dependencyContextResolver
+    )
   );
   const findings = [];
+  const moduleContractCache = /* @__PURE__ */ new Map();
   let dependencyRules;
   let dependencyRulesSkipReason;
   if (options.dependencyRulesConfigOverride) {
@@ -217792,7 +218000,8 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         if (parsedArchitectureContract) {
           const dependencyMetadata = resolveImportDependencyContextMetadata(
             parsedArchitectureContract,
-            dependencyImport
+            dependencyImport,
+            dependencyContextResolver
           );
           if (dependencyMetadata.isExternal) {
             return false;
@@ -217816,7 +218025,11 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         });
       } else {
         for (const violation of violations) {
-          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(parsedArchitectureContract, violation) : void 0;
+          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(
+            parsedArchitectureContract,
+            violation,
+            dependencyContextResolver
+          ) : void 0;
           const allowedDependencies = dependencyRules.modules[violation.sourceModule]?.allowedDependencies ?? [];
           const allowedDescription = allowedDependencies.length === 0 ? "may not depend on any other modules" : `may only depend on: ${allowedDependencies.join(", ")}`;
           findings.push({
@@ -217853,19 +218066,50 @@ 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
+            dependencyImport,
+            dependencyContextResolver
           );
           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(
@@ -217877,7 +218121,11 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         });
       } else {
         for (const violation of violations) {
-          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(parsedArchitectureContract, violation) : void 0;
+          const dependencyMetadata = parsedArchitectureContract ? resolveImportDependencyContextMetadata(
+            parsedArchitectureContract,
+            violation,
+            dependencyContextResolver
+          ) : void 0;
           const publicImportGuidance = await describeModulePublicImportGuidance(
             workspaceRoot,
             violation.targetModule,
@@ -218014,6 +218262,7 @@ var init_dependencyValidation = __esm({
     init_architectureDependencyContext();
     init_moduleDiscovery();
     init_stackAdapters();
+    init_sourceScopeClassification();
     dependencyRulesConfigFile = ".archpilot/dependency-rules.json";
     DependencyRulesConfigError = class extends Error {
     };
@@ -218021,7 +218270,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 +218323,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 +218655,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 +218677,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 +218692,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 +218710,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 +218890,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 +218951,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 +218975,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 +218998,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 +219012,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 +219139,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 +219205,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 +219286,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 +219298,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 +219342,7 @@ var init_moduleDetection = __esm({
       "scripts",
       "test",
       "tests",
+      "cypress-tests",
       "__tests__",
       "fixtures",
       "docs",
@@ -219307,7 +219566,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 +219588,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 +219633,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 +219743,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 +219774,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 +219790,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 +219874,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 +219999,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 +220897,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 +220915,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 +220929,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 +220971,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 +220991,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 +221024,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 +221087,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(
@@ -220892,7 +221147,7 @@ async function generateMissingModuleContracts(workspaceRoot) {
       });
       createdContracts.push(contractPath);
     }
-    if (isRegistryEntryDifferent({
+    if (moduleEntry.discoverySource === "architecture.json" && isRegistryEntryDifferent({
       contract,
       moduleName: moduleEntry.moduleName,
       sourcePath,
@@ -220941,7 +221196,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 +221299,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 +222126,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 +222142,8 @@ function buildArchitectureDriftSummary(results, _suppressedResults = []) {
   return {
     detected: areas.length > 0,
     areas,
-    message: formatArchitectureDriftSummaryMessage(areas)
+    message: formatArchitectureDriftSummaryMessage(areas),
+    baselineAvailable: true
   };
 }
 
@@ -222179,7 +222443,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 +222481,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 +222585,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 +222594,7 @@ async function readValidationSuppressions(workspaceRoot, knownRuleIds) {
     suppressions.push({
       index,
       ruleId,
-      ...entryScopeValue ? { scope: normalizePath9(entryScopeValue) } : {},
+      ...entryScopeValue ? { scope: normalizePath10(entryScopeValue) } : {},
       ...reason ? { reason } : {},
       ...expiresOn ? { expiresOn } : {}
     });
@@ -225107,66 +225371,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 +225380,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 +226191,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 +226278,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 +226287,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 isNonCollectionOrmRead(label, 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, 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 +226335,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 +226360,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 +226458,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",
@@ -226577,17 +226795,40 @@ function getModulePathForName(contract, moduleName) {
   const reference = contract.modules?.[moduleName];
   return normalizePath11(reference?.path ?? `${modulesRoot}/${moduleName}`);
 }
-function getPathSegmentsInsideModule(relativePath, modulePath) {
+function getComponentEntries2(contract) {
+  const components = contract.components;
+  if (!components) {
+    return [];
+  }
+  return Array.isArray(components) ? components.map((component, index) => [
+    typeof component.id === "string" && component.id.trim().length > 0 ? component.id.trim() : `component-${index}`,
+    component
+  ]) : Object.entries(components);
+}
+function getComponentPathForFile(contract, relativePath) {
   const normalized = normalizePath11(relativePath).toLowerCase();
-  if (!modulePath) {
+  const candidates = getComponentEntries2(contract).map(([, component]) => component.path).filter(
+    (componentPath) => typeof componentPath === "string" && componentPath.trim().length > 0
+  ).map((componentPath) => normalizePath11(componentPath)).filter((componentPath) => {
+    const normalizedComponentPath = componentPath.toLowerCase();
+    return normalized === normalizedComponentPath || normalized.startsWith(`${normalizedComponentPath}/`);
+  }).sort((left, right) => right.length - left.length || left.localeCompare(right));
+  return candidates[0];
+}
+function getOwnershipPathForFile(contract, relativePath, moduleName) {
+  return getModulePathForName(contract, moduleName) ?? getComponentPathForFile(contract, relativePath);
+}
+function getPathSegmentsInsideModule(relativePath, ownershipPath) {
+  const normalized = normalizePath11(relativePath).toLowerCase();
+  if (!ownershipPath) {
     return normalized.split("/");
   }
-  const normalizedModulePath = normalizePath11(modulePath).toLowerCase();
-  if (normalized === normalizedModulePath) {
+  const normalizedOwnershipPath = normalizePath11(ownershipPath).toLowerCase();
+  if (normalized === normalizedOwnershipPath) {
     return [];
   }
-  if (normalized.startsWith(`${normalizedModulePath}/`)) {
-    return normalized.slice(normalizedModulePath.length + 1).split("/");
+  if (normalized.startsWith(`${normalizedOwnershipPath}/`)) {
+    return normalized.slice(normalizedOwnershipPath.length + 1).split("/");
   }
   return normalized.split("/");
 }
@@ -226723,7 +226964,10 @@ function createFinding(input2) {
 function hasRepositoryLayer(files, contract) {
   return files.some((file) => {
     const moduleName = inferModuleForPath2(contract, file.relativePath);
-    return classifySourceFile(file, getModulePathForName(contract, moduleName)).isRepository;
+    return classifySourceFile(
+      file,
+      getOwnershipPathForFile(contract, file.relativePath, moduleName)
+    ).isRepository;
   });
 }
 function hasServiceLayer(files) {
@@ -226912,35 +227156,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 +227187,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);
@@ -227046,7 +227289,7 @@ async function detectApplicationLayeringFindings(input2) {
     const moduleName = inferModuleForPath2(input2.contract, file.relativePath);
     const classification = classifySourceFile(
       file,
-      getModulePathForName(input2.contract, moduleName),
+      getOwnershipPathForFile(input2.contract, file.relativePath, moduleName),
       input2.astCache
     );
     const candidates = [
@@ -227694,6 +227937,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 +228981,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 +229012,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 +229268,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 +229785,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 +231470,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 +242863,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 +243003,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 +243018,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 +243322,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 +245073,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 +245224,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 +245232,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 +245316,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 +245430,8 @@ function isIgnoredComponentCandidatePath(componentPath) {
   const ignoredRootSegments = [
     "tests",
     "test",
+    "cypress",
+    "cypress-tests",
     "__tests__",
     "fixtures",
     "smoke",
@@ -245214,8 +245499,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 +245524,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;
@@ -245246,7 +245540,15 @@ function readMavenMetadata(workspaceRoot, componentPath) {
     artifactId: readFirstXmlTag(normalizedPom, "artifactId"),
     name: readFirstXmlTag(normalizedPom, "name"),
     hasPom: true,
+    hasModules: /<modules\b/iu.test(normalizedPom),
     hasDependencyManagement: /<dependencyManagement\b/iu.test(normalizedPom),
+    hasSpringBootPlugin: /\bspring-boot-maven-plugin\b/iu.test(normalizedPom),
+    hasSpringBootRepackageGoal: /<goal>\s*repackage\s*<\/goal>/iu.test(normalizedPom),
+    configuredMainClass: readFirstXmlTag(normalizedPom, "mainClass") ?? readFirstXmlTag(normalizedPom, "start-class"),
+    hasSpringBootStarterDependency: dependencyBlocks.some((block) => /<artifactId>\s*spring-boot-starter(?:-[^<]+)?\s*<\/artifactId>/iu.test(block)),
+    hasSpringBootAutoconfigureDependency: dependencyBlocks.some((block) => /<artifactId>\s*spring-boot-autoconfigure\s*<\/artifactId>/iu.test(block)),
+    hasSpringBootAutoconfigureProcessor: /spring-boot-autoconfigure-processor|spring-boot-configuration-processor/iu.test(normalizedPom),
+    hasDocumentationTooling: /asciidoctor-maven-plugin|maven-site-plugin|doxia|antora|javadoc|<goal>\s*site\s*<\/goal>/iu.test(normalizedPom),
     testScopedDependencyCount: dependencyBlocks.filter((block) => /<scope>\s*test\s*<\/scope>/iu.test(block)).length,
     totalDependencyCount: dependencyBlocks.length,
     hasMavenPluginConfiguration: packaging === "maven-plugin" || /maven-plugin-plugin|<goalPrefix>|<mojo/iu.test(normalizedPom),
@@ -245329,21 +245631,384 @@ 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 hasFileUnderRoot(root, pattern) {
+  if (!pathExists19(root)) {
+    return false;
+  }
+  const entries = fs58.readdirSync(root, { recursive: true, withFileTypes: true });
+  return entries.some((entry) => entry.isFile() && pattern.test(entry.name));
+}
+var javaMainMethodPattern = /\bpublic\s+static\s+void\s+main\s*\(\s*String\s*(?:(?:\[\s*\]\s*)|\.\.\.\s*)[A-Za-z_$][\w$]*\s*(?:\[\s*\])?\s*\)/u;
+function stripJavaLikeCommentsAndStrings(value) {
+  let result = "";
+  let index = 0;
+  let state = "code";
+  while (index < value.length) {
+    const current = value[index] ?? "";
+    const next = value[index + 1] ?? "";
+    const nextTwo = value.slice(index, index + 3);
+    if (state === "code") {
+      if (current === "/" && next === "/") {
+        result += "  ";
+        index += 2;
+        state = "line-comment";
+        continue;
+      }
+      if (current === "/" && next === "*") {
+        result += "  ";
+        index += 2;
+        state = "block-comment";
+        continue;
+      }
+      if (nextTwo === '"""') {
+        result += "   ";
+        index += 3;
+        state = "text-block";
+        continue;
+      }
+      if (current === '"') {
+        result += " ";
+        index += 1;
+        state = "string";
+        continue;
+      }
+      if (current === "'") {
+        result += " ";
+        index += 1;
+        state = "char";
+        continue;
+      }
+      result += current;
+      index += 1;
+      continue;
+    }
+    if (state === "line-comment") {
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      if (current === "\n") {
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "block-comment") {
+      if (current === "*" && next === "/") {
+        result += "  ";
+        index += 2;
+        state = "code";
+        continue;
+      }
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      continue;
+    }
+    if (state === "text-block") {
+      if (nextTwo === '"""') {
+        result += "   ";
+        index += 3;
+        state = "code";
+        continue;
+      }
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      continue;
+    }
+    if (state === "string") {
+      if (current === "\\") {
+        result += " ";
+        index += next ? 2 : 1;
+        if (next) {
+          result += " ";
+        }
+        continue;
+      }
+      result += current === "\n" || current === "\r" ? current : " ";
+      index += 1;
+      if (current === '"') {
+        state = "code";
+      }
+      continue;
+    }
+    if (current === "\\") {
+      result += " ";
+      index += next ? 2 : 1;
+      if (next) {
+        result += " ";
+      }
+      continue;
+    }
+    result += current === "\n" || current === "\r" ? current : " ";
+    index += 1;
+    if (current === "'") {
+      state = "code";
+    }
+  }
+  return result;
+}
+function readMavenProductionSourceFiles(workspaceRoot, componentPath) {
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
+  const mainRoots = [
+    path64.join(absoluteRoot, "src", "main", "java"),
+    path64.join(absoluteRoot, "src", "main", "kotlin"),
+    path64.join(absoluteRoot, "src", "main", "scala")
+  ];
+  const files = [];
+  for (const sourceRoot of mainRoots) {
+    if (!pathExists19(sourceRoot)) {
+      continue;
+    }
+    const entries = fs58.readdirSync(sourceRoot, { recursive: true, withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || !/\.(?:java|kt|scala)$/iu.test(entry.name)) {
+        continue;
+      }
+      const contents = readTextFileSafe(path64.join(entry.parentPath, entry.name));
+      if (contents) {
+        files.push({ fileName: entry.name, contents });
+      }
+    }
+  }
+  return files;
+}
+function findMatchingBrace6(value, openBraceIndex) {
+  let depth = 0;
+  for (let index = openBraceIndex; index < value.length; index += 1) {
+    const current = value[index];
+    if (current === "{") {
+      depth += 1;
+    } else if (current === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return index;
+      }
+    }
+  }
+  return -1;
+}
+function getDeclaredPackageName(value) {
+  return value.match(/\bpackage\s+([a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)*)\s*;/u)?.[1];
+}
+function classNameMatchesConfiguredMainClass(className, packageName, configuredMainClass) {
+  const normalized = configuredMainClass.trim();
+  if (normalized.length === 0) {
+    return false;
+  }
+  return normalized === className || (packageName ? normalized === `${packageName}.${className}` : false);
+}
+function normalizeAnnotationName(value) {
+  return value.slice(value.lastIndexOf(".") + 1);
+}
+function hasAnnotation(annotations, annotationNames) {
+  return annotations.some((annotation) => annotationNames.has(normalizeAnnotationName(annotation)));
+}
+function extractAnnotations(annotationBlock) {
+  return [...annotationBlock.matchAll(/@\s*([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*)/gu)].map((match) => match[1]).filter((annotation) => Boolean(annotation));
+}
+function extractConcreteClassDeclarations(contents) {
+  const sanitized = stripJavaLikeCommentsAndStrings(contents);
+  const packageName = getDeclaredPackageName(sanitized);
+  const classPattern = /((?:@\s*[\w.]+(?:\s*\([^)]*\))?\s*)*)(?:public\s+|protected\s+|private\s+|abstract\s+|final\s+|sealed\s+|non-sealed\s+|static\s+)*class\s+([A-Za-z_$][\w$]*)[^{]*\{/gu;
+  const declarations = [];
+  for (const match of sanitized.matchAll(classPattern)) {
+    const annotationBlock = match[1] ?? "";
+    const className = match[2] ?? "";
+    const openBraceIndex = (match.index ?? 0) + match[0].length - 1;
+    const closeBraceIndex = findMatchingBrace6(sanitized, openBraceIndex);
+    if (closeBraceIndex < 0) {
+      continue;
+    }
+    declarations.push({
+      className,
+      ...packageName ? { packageName } : {},
+      annotations: extractAnnotations(annotationBlock),
+      body: sanitized.slice(openBraceIndex + 1, closeBraceIndex)
+    });
+  }
+  return declarations;
+}
+function extractApplicationAnnotationNames(sourceFiles) {
+  const applicationAnnotations = /* @__PURE__ */ new Set(["SpringBootApplication"]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const sourceFile of sourceFiles) {
+      const sanitized = stripJavaLikeCommentsAndStrings(sourceFile.contents);
+      const annotationPattern = /((?:@\s*[\w.]+(?:\s*\([^)]*\))?\s*)*)public\s+@interface\s+([A-Za-z_$][\w$]*)\b/gu;
+      for (const match of sanitized.matchAll(annotationPattern)) {
+        const annotations = extractAnnotations(match[1] ?? "");
+        const annotationName = match[2];
+        if (annotationName && !applicationAnnotations.has(annotationName) && hasAnnotation(annotations, applicationAnnotations)) {
+          applicationAnnotations.add(annotationName);
+          changed = true;
+        }
+      }
+    }
+  }
+  return applicationAnnotations;
+}
+function hasSpringApplicationRunForClass(body, className) {
+  return new RegExp(`\\bSpringApplication\\.run\\s*\\(\\s*${className}\\.class\\b`, "u").test(body);
+}
+function hasIndirectSpringApplicationRunForClass(body, className) {
+  const helperCalls = [...body.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(\s*([A-Za-z_$][\w$]*)\.class\s*,/gu)].filter((match) => match[2] === className).map((match) => match[1]).filter((methodName) => Boolean(methodName));
+  return helperCalls.some(
+    (methodName) => new RegExp(`\\b${methodName}\\s*\\([^)]*\\)\\s*\\{[\\s\\S]*?\\bSpringApplication\\.run\\s*\\(`, "u").test(body)
+  );
+}
+function hasConcreteSpringBootApplicationBootstrap(sourceFiles) {
+  const applicationAnnotations = extractApplicationAnnotationNames(sourceFiles);
+  const declarations = sourceFiles.flatMap((sourceFile) => extractConcreteClassDeclarations(sourceFile.contents));
+  const applicationClassNames = new Set(
+    declarations.filter((declaration) => hasAnnotation(declaration.annotations, applicationAnnotations)).map((declaration) => declaration.className)
+  );
+  if (applicationClassNames.size === 0) {
+    return false;
+  }
+  const hasLauncherForApplicationClass = (declaration) => javaMainMethodPattern.test(declaration.body) && [...applicationClassNames].some(
+    (applicationClassName) => hasSpringApplicationRunForClass(declaration.body, applicationClassName) || applicationClassName === declaration.className && hasIndirectSpringApplicationRunForClass(declaration.body, applicationClassName)
+  );
+  if (declarations.some(hasLauncherForApplicationClass)) {
+    return true;
+  }
+  for (const sourceFile of sourceFiles) {
+    for (const declaration of extractConcreteClassDeclarations(sourceFile.contents)) {
+      if (!hasAnnotation(declaration.annotations, applicationAnnotations)) {
+        continue;
+      }
+      if (javaMainMethodPattern.test(declaration.body) && (hasSpringApplicationRunForClass(declaration.body, declaration.className) || hasIndirectSpringApplicationRunForClass(declaration.body, declaration.className))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasConfiguredMainClassEntrypoint(contents, configuredMainClass) {
+  for (const declaration of extractConcreteClassDeclarations(contents)) {
+    if (!classNameMatchesConfiguredMainClass(declaration.className, declaration.packageName, configuredMainClass)) {
+      continue;
+    }
+    if (javaMainMethodPattern.test(declaration.body)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasMavenMainEntrypoint(workspaceRoot, componentPath) {
+  return hasConcreteSpringBootApplicationBootstrap(readMavenProductionSourceFiles(workspaceRoot, componentPath));
+}
+function hasMavenConfiguredMainClassEntrypoint(workspaceRoot, componentPath, configuredMainClass) {
+  if (!configuredMainClass) {
+    return false;
+  }
+  return readMavenProductionSourceFiles(workspaceRoot, componentPath).some((sourceFile) => hasConfiguredMainClassEntrypoint(sourceFile.contents, configuredMainClass));
+}
+function hasMavenAutoConfigurationMetadata(workspaceRoot, componentPath) {
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
+  return [
+    path64.join(absoluteRoot, "src", "main", "resources", "META-INF", "spring.factories"),
+    path64.join(absoluteRoot, "src", "main", "resources", "META-INF", "spring", "org.springframework.boot.autoconfigure.AutoConfiguration.imports")
+  ].some(pathExists19);
+}
+function hasMavenMainJvmSource(workspaceRoot, componentPath) {
+  const absoluteRoot = absoluteComponentRoot(workspaceRoot, componentPath);
+  return [
+    path64.join(absoluteRoot, "src", "main", "java"),
+    path64.join(absoluteRoot, "src", "main", "kotlin"),
+    path64.join(absoluteRoot, "src", "main", "scala")
+  ].some((root) => hasFileUnderRoot(root, /\.(?:java|kt|scala)$/iu));
+}
+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 maven = readMavenMetadata(workspaceRoot, candidate.path);
+  const hasRunnableFrontendEvidence = hasRunnableFrontendComponentEvidence(workspaceRoot, candidate.path);
+  const hasPublishSurface = hasPackagePublishSurface(packageJson);
+  const hasMavenRunnableEvidence = Boolean(
+    maven && (hasMavenMainEntrypoint(workspaceRoot, candidate.path) || hasMavenConfiguredMainClassEntrypoint(workspaceRoot, candidate.path, maven.configuredMainClass) || maven.hasSpringBootPlugin && maven.hasSpringBootRepackageGoal && hasMavenMainEntrypoint(workspaceRoot, candidate.path) || maven.packaging === "war" && hasMavenMainEntrypoint(workspaceRoot, candidate.path))
+  );
+  const hasMavenLibraryEvidence = Boolean(
+    maven && !hasMavenRunnableEvidence && (maven.packaging === "jar" || maven.packaging === "maven-plugin" || maven.packaging === "pom") && (hasMavenMainJvmSource(workspaceRoot, candidate.path) || maven.hasMainResources || maven.hasDependencyManagement || maven.hasSpringBootAutoconfigureDependency || maven.hasSpringBootAutoconfigureProcessor || hasMavenAutoConfigurationMetadata(workspaceRoot, candidate.path) || maven.hasDocumentationTooling || maven.hasTestJava || maven.hasTestResources)
+  );
   if (lowerPath.endsWith("/db") || lowerPath.endsWith("/database") || lowerPath.endsWith("/data")) {
     return "data";
   }
+  if (hasMavenLibraryEvidence) {
+    return "library";
+  }
+  if (maven && !hasMavenRunnableEvidence && localProjectKinds.primaryKind === "backend") {
+    return "library";
+  }
   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,15 +246077,21 @@ 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();
   const hasMavenMainSource = Boolean(maven?.hasMainJava || maven?.hasMainResources);
   const hasMavenTestSource = Boolean(maven?.hasTestJava || maven?.hasTestResources);
+  const hasMavenMainEntrypointEvidence = Boolean(maven && hasMavenMainEntrypoint(input2.workspaceRoot, input2.candidate.path));
+  const hasMavenMainJvmSourceEvidence = Boolean(maven && hasMavenMainJvmSource(input2.workspaceRoot, input2.candidate.path));
+  const hasMavenAutoConfigurationEvidence = Boolean(maven && (hasMavenAutoConfigurationMetadata(input2.workspaceRoot, input2.candidate.path) || maven.hasSpringBootAutoconfigureDependency || maven.hasSpringBootAutoconfigureProcessor));
+  const hasMavenExecutableConfiguration = Boolean(maven && (hasMavenConfiguredMainClassEntrypoint(input2.workspaceRoot, input2.candidate.path, maven.configuredMainClass) || maven.hasSpringBootPlugin && maven.hasSpringBootRepackageGoal && hasMavenMainEntrypointEvidence || maven.packaging === "war" && hasMavenMainEntrypointEvidence));
+  const hasMavenRunnableApplicationEvidence = Boolean(hasMavenMainEntrypointEvidence || hasMavenExecutableConfiguration);
   const isMavenPomOnly = Boolean(maven?.packaging === "pom" && !hasMavenMainSource && !hasMavenTestSource);
   const hasMavenTestContext = hasAnyToken(pathText, [
     /(^|\/)(test-framework|testsuite|integration-tests?|test-apps)(\/|$)/u
@@ -245459,17 +246130,19 @@ function classifyGovernanceRole(input2) {
   if (maven?.hasPom) {
     addEvidence6(evidence, `Maven packaging ${maven.packaging ?? "jar"}`);
   }
-  if (maven && (maven.packaging === "jar" || maven.packaging === "war") && hasMavenMainSource) {
+  if (maven && (maven.packaging === "jar" || maven.packaging === "war") && hasMavenRunnableApplicationEvidence) {
     runtimeScore += 3;
-    addEvidence6(evidence, "Maven runtime source layout");
+    addEvidence6(evidence, "Maven executable application evidence");
   }
-  if (maven?.packaging === "war" && hasMavenMainSource) {
+  if (maven?.packaging === "war" && hasMavenMainJvmSourceEvidence) {
     runtimeScore += 1;
     addEvidence6(evidence, "Maven deployable WAR artifact");
   }
-  if (maven && hasMavenMainSource && !hasMavenTestContext && !hasMavenBomEvidence && maven.packaging !== "maven-plugin") {
-    runtimeScore += 1;
-    addEvidence6(evidence, "Maven main source/resource surface");
+  if (maven && hasMavenMainSource && !hasMavenRunnableApplicationEvidence && !hasMavenTestContext && !hasMavenBomEvidence && maven.packaging !== "maven-plugin") {
+    addEvidence6(evidence, "Maven library main source/resource surface");
+  }
+  if (hasMavenAutoConfigurationEvidence && !hasMavenRunnableApplicationEvidence) {
+    addEvidence6(evidence, "Maven Spring Boot auto-configuration/starter library evidence");
   }
   if (hasAnyToken(descriptiveManifestText, [/\b(e2e|end-to-end|testing|test helper|test utilities|fixtures?)\b/u])) {
     supportScore += 3;
@@ -245484,7 +246157,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;
@@ -245510,6 +246183,10 @@ function classifyGovernanceRole(input2) {
     supportScore += 5;
     addEvidence6(evidence, "Maven plugin/build-tooling module");
   }
+  if (maven?.hasDocumentationTooling && !hasMavenMainJvmSourceEvidence) {
+    supportScore += 4;
+    addEvidence6(evidence, "Maven documentation tooling without JVM runtime source");
+  }
   if (hasMavenBomEvidence) {
     supportScore += 5;
     addEvidence6(evidence, "Maven BOM/dependency-management module without runtime source");
@@ -245534,6 +246211,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 +246235,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 +246278,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 +246304,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 +246541,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");
 }
@@ -245885,7 +246579,7 @@ function isCliSupportCandidate(component, allComponents) {
 }
 function hasIndependentRuntimeEvidence(component) {
   const text = componentEvidenceText(component);
-  return component.governanceRole === "runtime" && (/Maven runtime source layout/iu.test(text) || /Maven main source\/resource surface/iu.test(text) || /Published package surface signal/iu.test(text) && !/Path contains support\/tooling role tokens/iu.test(text));
+  return component.governanceRole === "runtime" && (/Maven executable application evidence/iu.test(text) || /Maven deployable WAR artifact/iu.test(text) || /Published package surface signal/iu.test(text) && !/Path contains support\/tooling role tokens/iu.test(text));
 }
 function hasSupportRoleEvidence(component) {
   const text = componentEvidenceText(component);
@@ -245990,7 +246684,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 +246720,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"),