@archpilotlabs/archpilot 0.0.8 → 0.0.10

package/dist/archpilot-cli.js

@@ -210932,6 +210932,7 @@ var import_node_fs = require("node:fs");
 var validProjectKinds = /* @__PURE__ */ new Set(["backend", "frontend", "library"]);
 var validCanonicalStackIds = /* @__PURE__ */ new Set([
   "node_typescript",
+  "express",
   "nestjs",
   "java",
   "spring",
@@ -210940,9 +210941,11 @@ var validCanonicalStackIds = /* @__PURE__ */ new Set([
   "flask",
   "python",
   "php",
+  "laravel",
   "go",
   "dotnet",
   "ruby_rails",
+  "kotlin",
   "kotlin_spring",
   "rust",
   "react",
@@ -210956,6 +210959,7 @@ var validCanonicalStackIds = /* @__PURE__ */ new Set([
 ]);
 var canonicalStackLabels = {
   node_typescript: "TypeScript / Node.js",
+  express: "Express.js",
   nestjs: "NestJS",
   java: "Java",
   spring: "Spring",
@@ -210964,9 +210968,11 @@ var canonicalStackLabels = {
   flask: "Flask",
   python: "Python",
   php: "PHP",
+  laravel: "Laravel",
   go: "Go",
   dotnet: ".NET",
   ruby_rails: "Ruby / Rails",
+  kotlin: "Kotlin",
   kotlin_spring: "Kotlin / Spring",
   rust: "Rust",
   react: "React",
@@ -211177,6 +211183,103 @@ var nodeTypescriptAdapter = buildAdapter({
 var stackAdaptersById = {
   other: genericDefaultAdapter,
   node_typescript: nodeTypescriptAdapter,
+  express: buildAdapter({
+    id: "express",
+    displayName: canonicalStackLabels.express,
+    ecosystem: "node",
+    category: "framework",
+    priority: 70,
+    manifestDetectionHints: ["package.json", "tsconfig.json", "app.js", "app.ts", "server.js", "server.ts"],
+    buildToolHints: ["npm", "pnpm", "yarn"],
+    defaults: {
+      sourceRoots: ["src", "."],
+      moduleRootCandidates: ["src/modules", "src/features", "routes", "src/routes", "src"],
+      apiRoots: ["routes", "src/routes", "src/api", "api"],
+      databaseRoots: ["prisma", "db", "database", "migrations"],
+      configFiles: ["package.json", "tsconfig.json"],
+      fileExtensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+      dependencyFileExtensions: [".ts", ".js", ".mjs", ".cjs"],
+      ignoreDirectories: ["node_modules", "dist", "coverage"],
+      entrypointHints: ["app.ts", "server.ts", "src/app.ts", "src/server.ts", "app.js", "server.js", "src/app.js", "src/server.js"],
+      publicEntrypointDirectories: ["public"],
+      moduleIndexFileName: "index.ts"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let score = 0;
+      const hasExpressDependency = context.hasPackageDependency("express");
+      const hasExpressFactory = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\bexpress\s*\(\s*\)/u
+      );
+      const hasExpressImport = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\b(import\s+express\s+from\s+['"]express['"]|require\s*\(\s*['"]express['"]\s*\))/u
+      );
+      const hasAppUse = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\bapp\.use\s*\(/u
+      );
+      const hasRouterUsage = context.hasAnyFileMatchingPattern(
+        /\.(ts|js|mjs|cjs)$/iu,
+        /\b(router|Router)\s*\.\s*(get|post|put|patch|delete|use)\s*\(/u
+      );
+      const hasRoutesDirectory = context.hasDirectory("routes") || context.hasDirectory("src/routes");
+      const hasRouteFiles = context.hasAnyPathMatchingPattern(/(^|\/)(routes|src\/routes)\/.+\.(ts|js|mjs|cjs)$/iu);
+      if (hasExpressDependency) {
+        strongSignals += 1;
+        score += 46;
+        evidence.push("Found package.json with express dependency");
+      }
+      if (hasExpressFactory) {
+        strongSignals += 1;
+        score += 28;
+        evidence.push("Found express() app construction");
+      }
+      if (hasExpressImport) {
+        mediumSignals += 1;
+        score += 12;
+        evidence.push("Found Express import or require");
+      }
+      if (hasAppUse) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found app.use(...) middleware or router mounting");
+      }
+      if (hasRouterUsage) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found router HTTP method usage");
+      }
+      if (hasRoutesDirectory) {
+        mediumSignals += 1;
+        score += 6;
+        evidence.push("Found routes/ or src/routes/ directory");
+      }
+      if (hasRouteFiles) {
+        mediumSignals += 1;
+        score += 5;
+        evidence.push("Found route files under routes/");
+      }
+      const hasSafeExpressEvidence = hasExpressDependency && (hasExpressFactory || hasExpressImport || hasAppUse || hasRouterUsage || hasRoutesDirectory);
+      if (!hasSafeExpressEvidence) {
+        return null;
+      }
+      const confidence = strongSignals >= 2 || strongSignals >= 1 && mediumSignals >= 2 ? "high" : strongSignals >= 1 ? "medium" : "low";
+      return toResult({
+        adapterId: "express",
+        confidence,
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: "rest"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "typescript-imports"
+  }),
   nestjs: buildAdapter({
     id: "nestjs",
     displayName: canonicalStackLabels.nestjs,
@@ -211452,9 +211555,9 @@ var stackAdaptersById = {
     ],
     buildToolHints: ["maven", "gradle"],
     defaults: {
-      sourceRoots: ["src/main/java", "src"],
-      moduleRootCandidates: ["src/main/java"],
-      apiRoots: ["src/main/java"],
+      sourceRoots: ["src/main/java", "src/main/kotlin", "src"],
+      moduleRootCandidates: ["src/main/java", "src/main/kotlin"],
+      apiRoots: ["src/main/java", "src/main/kotlin"],
       databaseRoots: ["src/main/resources", "src/main/resources/db"],
       configFiles: [
         "pom.xml",
@@ -211474,7 +211577,7 @@ var stackAdaptersById = {
         "out",
         ...commonIgnoreDirectories
       ],
-      entrypointHints: ["src/main/java"],
+      entrypointHints: ["src/main/java", "src/main/kotlin", "Application.java", "Application.kt"],
       publicEntrypointDirectories: [],
       moduleIndexFileName: "Application.java"
     },
@@ -211500,7 +211603,7 @@ var stackAdaptersById = {
         /\.(java|kt)$/iu,
         /@SpringBootApplication\b/u
       );
-      const hasMainJavaWithDependencies = context.hasDirectory("src/main/java") && hasSpringDependencyEvidence;
+      const hasMainSourceWithDependencies = (context.hasDirectory("src/main/java") || context.hasDirectory("src/main/kotlin")) && hasSpringDependencyEvidence;
       const hasApplicationConfigWithDependencies = (context.hasFile("application.yml") || context.hasFile("application.yaml") || context.hasFile("application.properties")) && hasSpringDependencyEvidence;
       const hasRestController = context.hasAnyFileMatchingPattern(
         /\.(java|kt)$/iu,
@@ -211524,9 +211627,9 @@ var stackAdaptersById = {
       );
       const hasResourcesDirectory = context.hasDirectory("src/main/resources");
       const hasWrapperWithSpringEvidence = (context.hasFile("mvnw") || context.hasFile("gradlew")) && hasSpringDependencyEvidence;
-      const hasTestJava = context.hasDirectory("src/test/java");
+      const hasTestJvmSource = context.hasDirectory("src/test/java") || context.hasDirectory("src/test/kotlin");
       const hasBootstrapConfig = context.hasFile("bootstrap.yml") || context.hasFile("bootstrap.yaml");
-      const hasJavaPackageShape = context.hasDirectory("src/main/java/com") || context.hasDirectory("src/main/java/org");
+      const hasJvmPackageShape = context.hasDirectory("src/main/java/com") || context.hasDirectory("src/main/java/org") || context.hasDirectory("src/main/kotlin/com") || context.hasDirectory("src/main/kotlin/org");
       if (hasPomSpringDependency) {
         strongSignals += 1;
         score += 54;
@@ -211542,10 +211645,10 @@ var stackAdaptersById = {
         score += 44;
         evidence.push("Found @SpringBootApplication in source");
       }
-      if (hasMainJavaWithDependencies) {
+      if (hasMainSourceWithDependencies) {
         strongSignals += 1;
         score += 20;
-        evidence.push("Found src/main/java with Spring dependency evidence");
+        evidence.push("Found JVM main source root with Spring dependency evidence");
       }
       if (hasApplicationConfigWithDependencies) {
         strongSignals += 1;
@@ -211587,22 +211690,22 @@ var stackAdaptersById = {
         score += 4;
         evidence.push("Found Maven/Gradle wrapper with Spring dependency evidence");
       }
-      if (hasTestJava) {
+      if (hasTestJvmSource) {
         weakSignals += 1;
         score += 2;
-        evidence.push("Found src/test/java directory");
+        evidence.push("Found JVM test source directory");
       }
       if (hasBootstrapConfig) {
         weakSignals += 1;
         score += 2;
         evidence.push("Found bootstrap.yml or bootstrap.yaml");
       }
-      if (hasJavaPackageShape) {
+      if (hasJvmPackageShape) {
         weakSignals += 1;
         score += 1;
-        evidence.push("Found conventional Java package directory under src/main/java");
+        evidence.push("Found conventional JVM package directory under main source root");
       }
-      const hasSafeSpringCoreEvidence = hasSpringDependencyEvidence || hasSpringBootApplication || (hasRestController || hasController || hasService || hasRepository || hasMappingAnnotation) && (context.hasDirectory("src/main/java") || hasResourcesDirectory);
+      const hasSafeSpringCoreEvidence = hasSpringDependencyEvidence || hasSpringBootApplication || (hasRestController || hasController || hasService || hasRepository || hasMappingAnnotation) && (context.hasDirectory("src/main/java") || context.hasDirectory("src/main/kotlin") || hasResourcesDirectory);
       if (!hasSafeSpringCoreEvidence || strongSignals === 0) {
         return null;
       }
@@ -212191,6 +212294,101 @@ var stackAdaptersById = {
     resolveProjectKinds: () => ["backend", "library"],
     getImportExtractionMode: () => "python-imports"
   }),
+  laravel: buildAdapter({
+    id: "laravel",
+    displayName: canonicalStackLabels.laravel,
+    ecosystem: "php",
+    category: "framework",
+    priority: 70,
+    manifestDetectionHints: ["composer.json", "artisan", "web.php", "api.php", "app.php"],
+    buildToolHints: ["composer", "artisan"],
+    defaults: {
+      sourceRoots: ["app", "routes", "config"],
+      moduleRootCandidates: ["app/Modules", "app/Services", "app/Http/Controllers", "app"],
+      apiRoots: ["routes", "app/Http/Controllers"],
+      databaseRoots: ["database", "database/migrations"],
+      configFiles: ["composer.json", "artisan", "config/app.php"],
+      fileExtensions: [".php"],
+      dependencyFileExtensions: [".php"],
+      ignoreDirectories: [
+        "vendor",
+        "storage",
+        "bootstrap/cache",
+        "public",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["artisan", "public/index.php", "bootstrap/app.php"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "index.php"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let score = 0;
+      const hasLaravelComposer = context.hasFileMatchingPattern(
+        "composer.json",
+        /["']laravel\/framework["']/iu
+      );
+      const hasArtisan = context.hasFile("artisan");
+      const hasRoutesWeb = context.hasAnyPathMatchingPattern(/(^|\/)routes\/web\.php$/iu);
+      const hasRoutesApi = context.hasAnyPathMatchingPattern(/(^|\/)routes\/api\.php$/iu);
+      const hasControllers = context.hasDirectory("app/Http/Controllers");
+      const hasConfigApp = context.hasAnyPathMatchingPattern(/(^|\/)config\/app\.php$/iu);
+      const hasLaravelRouteFacade = context.hasAnyFileMatchingPattern(
+        /(^|\/)routes\/.+\.php$/iu,
+        /\bRoute::(get|post|put|patch|delete|middleware|group)\s*\(/u
+      );
+      if (hasLaravelComposer) {
+        strongSignals += 1;
+        score += 50;
+        evidence.push("Found composer.json with laravel/framework dependency");
+      }
+      if (hasArtisan) {
+        strongSignals += 1;
+        score += 18;
+        evidence.push("Found artisan entrypoint");
+      }
+      if (hasRoutesWeb) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found routes/web.php");
+      }
+      if (hasRoutesApi) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found routes/api.php");
+      }
+      if (hasControllers) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found app/Http/Controllers directory");
+      }
+      if (hasConfigApp) {
+        mediumSignals += 1;
+        score += 6;
+        evidence.push("Found config/app.php");
+      }
+      if (hasLaravelRouteFacade) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Laravel Route facade usage");
+      }
+      if (!hasLaravelComposer || !(hasArtisan || hasRoutesWeb || hasRoutesApi || hasControllers)) {
+        return null;
+      }
+      return toResult({
+        adapterId: "laravel",
+        confidence: strongSignals >= 2 || mediumSignals >= 2 ? "high" : "medium",
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRoutesApi || hasLaravelRouteFacade ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "php-imports"
+  }),
   php: buildAdapter({
     id: "php",
     displayName: canonicalStackLabels.php,
@@ -212478,23 +212676,182 @@ var stackAdaptersById = {
     displayName: canonicalStackLabels.ruby_rails,
     ecosystem: "other",
     category: "framework",
-    priority: 20,
-    manifestDetectionHints: ["Gemfile"],
+    priority: 70,
+    manifestDetectionHints: ["Gemfile", "rails", "routes.rb", "application.rb"],
     buildToolHints: ["bundle"],
     defaults: {
-      sourceRoots: ["app"],
-      moduleRootCandidates: ["app"],
-      apiRoots: ["app/controllers"],
+      sourceRoots: ["app", "config"],
+      moduleRootCandidates: ["app/services", "app/controllers", "app/models", "app"],
+      apiRoots: ["app/controllers", "config/routes.rb"],
       databaseRoots: ["db"],
-      configFiles: ["Gemfile"],
+      configFiles: ["Gemfile", "config/routes.rb", "config/application.rb"],
       fileExtensions: [".rb"],
       dependencyFileExtensions: [".rb"],
-      ignoreDirectories: [...commonIgnoreDirectories],
+      ignoreDirectories: ["vendor", "tmp", "log", ...commonIgnoreDirectories],
       entrypointHints: ["config/application.rb"],
       publicEntrypointDirectories: [],
       moduleIndexFileName: "application.rb"
     },
-    detect: () => null,
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let score = 0;
+      const hasRailsGem = context.hasFileMatchingPattern("Gemfile", /\bgem\s+['"]rails['"]/u);
+      const hasBinRails = context.hasAnyPathMatchingPattern(/(^|\/)bin\/rails$/u);
+      const hasRoutes = context.hasAnyPathMatchingPattern(/(^|\/)config\/routes\.rb$/u);
+      const hasControllers = context.hasDirectory("app/controllers");
+      const hasModels = context.hasDirectory("app/models");
+      const hasServices = context.hasDirectory("app/services");
+      const hasRailsRoutesDraw = context.hasFileMatchingPattern("routes.rb", /\bRails\.application\.routes\.draw\b/u);
+      const hasApplicationClass = context.hasAnyFileMatchingPattern(
+        /(^|\/)config\/application\.rb$/u,
+        /\bclass\s+Application\s+<\s+Rails::Application\b/u
+      );
+      const hasApplicationController = context.hasAnyFileMatchingPattern(
+        /(^|\/)app\/controllers\/.+\.rb$/u,
+        /\bApplicationController\b/u
+      );
+      if (hasRailsGem) {
+        strongSignals += 1;
+        score += 48;
+        evidence.push("Found Gemfile with rails gem");
+      }
+      if (hasBinRails) {
+        strongSignals += 1;
+        score += 18;
+        evidence.push("Found bin/rails");
+      }
+      if (hasRoutes) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found config/routes.rb");
+      }
+      if (hasControllers) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found app/controllers directory");
+      }
+      if (hasModels) {
+        mediumSignals += 1;
+        score += 6;
+        evidence.push("Found app/models directory");
+      }
+      if (hasServices) {
+        mediumSignals += 1;
+        score += 5;
+        evidence.push("Found app/services directory");
+      }
+      if (hasRailsRoutesDraw) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Rails routes draw block");
+      }
+      if (hasApplicationClass) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Rails application class");
+      }
+      if (hasApplicationController) {
+        mediumSignals += 1;
+        score += 5;
+        evidence.push("Found ApplicationController inheritance");
+      }
+      if (!hasRailsGem || !(hasBinRails || hasRoutes || hasControllers || hasApplicationClass)) {
+        return null;
+      }
+      return toResult({
+        adapterId: "ruby_rails",
+        confidence: strongSignals >= 2 || mediumSignals >= 3 ? "high" : "medium",
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRoutes || hasControllers ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "generic"
+  }),
+  kotlin: buildAdapter({
+    id: "kotlin",
+    displayName: canonicalStackLabels.kotlin,
+    ecosystem: "jvm",
+    category: "generic-language",
+    priority: 40,
+    manifestDetectionHints: ["build.gradle.kts", "pom.xml", "settings.gradle.kts"],
+    buildToolHints: ["gradle", "maven"],
+    defaults: {
+      sourceRoots: ["src/main/kotlin", "src"],
+      moduleRootCandidates: ["src/main/kotlin", "src"],
+      apiRoots: ["src/main/kotlin"],
+      databaseRoots: ["src/main/resources/db", "src/main/resources/migrations"],
+      configFiles: ["build.gradle.kts", "pom.xml", "settings.gradle.kts"],
+      fileExtensions: [".kt", ".kts"],
+      dependencyFileExtensions: [".kt", ".kts"],
+      ignoreDirectories: [
+        "target",
+        "build",
+        ".gradle",
+        ".idea",
+        "out",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["Application.kt", "Main.kt"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "Application.kt"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let score = 0;
+      const hasBuildGradleKts = context.hasFile("build.gradle.kts");
+      const hasSettingsGradleKts = context.hasFile("settings.gradle.kts");
+      const hasKotlinPluginInGradle = context.hasFileMatchingPattern("build.gradle.kts", /\bkotlin\s*\(\s*["']jvm["']\s*\)/u) || context.hasFileMatchingPattern("build.gradle.kts", /\bid\s*\(\s*["']org\.jetbrains\.kotlin\.jvm["']\s*\)/u);
+      const hasPomKotlinPlugin = context.hasFileMatchingPattern("pom.xml", /\bkotlin-maven-plugin\b/u) || context.hasFileMatchingPattern("pom.xml", /\borg\.jetbrains\.kotlin\b/u);
+      const hasKotlinSourceRoot = context.hasDirectory("src/main/kotlin");
+      const hasKtFiles = context.hasFileExtension(".kt") || context.hasFileExtension(".kts");
+      const hasKotlinPackageShape = context.hasDirectory("src/main/kotlin/com") || context.hasDirectory("src/main/kotlin/org");
+      if (hasBuildGradleKts) {
+        score += 30;
+        evidence.push("Found build.gradle.kts");
+      }
+      if (hasSettingsGradleKts) {
+        score += 8;
+        evidence.push("Found settings.gradle.kts");
+      }
+      if (hasKotlinPluginInGradle) {
+        score += 32;
+        evidence.push("Found Kotlin JVM plugin in build.gradle.kts");
+      }
+      if (hasPomKotlinPlugin) {
+        score += 32;
+        evidence.push("Found Kotlin Maven plugin markers in pom.xml");
+      }
+      if (hasKotlinSourceRoot) {
+        score += 18;
+        evidence.push("Found src/main/kotlin source root");
+      }
+      if (hasKtFiles) {
+        score += 16;
+        evidence.push("Found Kotlin source files");
+      }
+      if (hasKotlinPackageShape) {
+        score += 4;
+        evidence.push("Found conventional Kotlin package directory under src/main/kotlin");
+      }
+      const hasSafeKotlinEvidence = hasKtFiles && (hasBuildGradleKts || hasKotlinPluginInGradle || hasPomKotlinPlugin || hasKotlinSourceRoot);
+      if (!hasSafeKotlinEvidence) {
+        return null;
+      }
+      return toResult({
+        adapterId: "kotlin",
+        confidence: (hasKotlinPluginInGradle || hasPomKotlinPlugin) && hasKotlinSourceRoot ? "high" : hasBuildGradleKts || hasKotlinSourceRoot ? "medium" : "low",
+        score,
+        evidence,
+        projectKindHints: ["backend", "library"],
+        apiStyleHint: "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend", "library"],
     getImportExtractionMode: () => "generic"
   }),
   kotlin_spring: buildAdapter({
@@ -212750,7 +213107,7 @@ var stackAdaptersById = {
       let score = 0;
       if (hasVueDependency) {
         strongSignals += 1;
-        score += 28;
+        score += 30;
         evidence.push("Found package.json with vue dependency");
       }
       if (hasAppVue) {
@@ -212765,12 +213122,12 @@ var stackAdaptersById = {
       }
       if (hasVitePluginInConfig) {
         strongSignals += 1;
-        score += 20;
+        score += 24;
         evidence.push("Found Vue plugin usage in vite.config.ts or vite.config.js");
       }
       if (hasVitePluginDependency) {
         strongSignals += 1;
-        score += 18;
+        score += 22;
         evidence.push("Found package.json with @vitejs/plugin-vue dependency");
       }
       if (hasSrcViews) {
@@ -212785,12 +213142,12 @@ var stackAdaptersById = {
       }
       if (hasCreateAppReference) {
         mediumSignals += 1;
-        score += 10;
+        score += 12;
         evidence.push("Found createApp usage in src/main.ts or src/main.js");
       }
       if (hasViteConfig && hasVueDependency) {
         mediumSignals += 1;
-        score += 6;
+        score += 8;
         evidence.push("Found vite.config.ts or vite.config.js with Vue package evidence");
       }
       if (hasTsConfigApp) {
@@ -213118,7 +213475,264 @@ async function listModuleDirectoryNames(workspaceRoot, modulesRootRelativePath =
   const entries = await import_node_fs.promises.readdir(modulesRoot, { withFileTypes: true });
   return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
 }
+var ignoredModuleDirectoryNames = /* @__PURE__ */ new Set([
+  ".git",
+  ".archpilot",
+  ".vscode",
+  ".vscode-test",
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  "generated",
+  "target",
+  "vendor",
+  ".venv",
+  "venv",
+  "__pycache__"
+]);
+var noisyModuleDirectoryNames = /* @__PURE__ */ new Set([
+  "components",
+  "hooks",
+  "utils",
+  "util",
+  "lib",
+  "common",
+  "shared",
+  "shared-ui",
+  "types",
+  "constants",
+  "config",
+  "test",
+  "tests",
+  "__tests__",
+  "fixtures",
+  "mocks",
+  "__mocks__",
+  "generated",
+  "dist",
+  "build",
+  "out",
+  "node_modules"
+]);
+var sourceFileExtensions = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".vue",
+  ".java",
+  ".py",
+  ".php",
+  ".go",
+  ".cs",
+  ".rb",
+  ".kt",
+  ".swift",
+  ".rs"
+]);
+var publicEntrypointNames = /* @__PURE__ */ new Set([
+  "index.ts",
+  "index.tsx",
+  "index.js",
+  "index.jsx",
+  "index.vue",
+  "__init__.py",
+  "main.go",
+  "mod.ts",
+  "mod.js"
+]);
+function isIgnoredDirectoryName(directoryName) {
+  return ignoredModuleDirectoryNames.has(directoryName.toLowerCase());
+}
+function isNoisyModuleName(moduleName) {
+  return noisyModuleDirectoryNames.has(moduleName.toLowerCase());
+}
+function toPathSegments(relativePath) {
+  return normalizePath(relativePath).split("/").filter((segment) => segment.length > 0);
+}
+function toModuleIdFromPath(relativePath, fallbackRoot) {
+  const segments = toPathSegments(relativePath);
+  const lowerSegments = segments.map((segment) => segment.toLowerCase());
+  const sourceIndex = lowerSegments.lastIndexOf("src");
+  if (sourceIndex >= 0 && sourceIndex + 2 < segments.length) {
+    const parent = segments[sourceIndex - 1];
+    const container = lowerSegments[sourceIndex + 1];
+    if (["modules", "features"].includes(container)) {
+      return [parent, segments[sourceIndex + 2]].filter(Boolean).join("/");
+    }
+    if (["domain", "domains", "application", "infrastructure"].includes(container)) {
+      return [segments[sourceIndex + 1], segments[sourceIndex + 2]].join("/");
+    }
+    return [parent, segments[sourceIndex + 1]].filter(Boolean).join("/");
+  }
+  if (sourceIndex >= 0 && sourceIndex + 1 < segments.length) {
+    const parent = segments[sourceIndex - 1];
+    return [parent, segments[sourceIndex + 1]].filter(Boolean).join("/");
+  }
+  if (segments[0] === "src" && segments.length >= 3) {
+    return `${segments[1]}/${segments[2]}`;
+  }
+  if (fallbackRoot) {
+    const rootSegments = toPathSegments(fallbackRoot);
+    const relativeSegments = segments.slice(rootSegments.length);
+    if (relativeSegments.length > 0) {
+      return relativeSegments.join("/");
+    }
+  }
+  return segments.slice(-1)[0] ?? relativePath;
+}
+function isKnownNestedModuleRoot(relativePath) {
+  const segments = toPathSegments(relativePath).map((segment) => segment.toLowerCase());
+  if (segments.length < 2) {
+    return false;
+  }
+  const lastParent = segments[segments.length - 2];
+  if (["modules", "features", "domain", "domains", "application", "infrastructure"].includes(lastParent)) {
+    return true;
+  }
+  if (segments.length >= 3 && segments[segments.length - 3] === "src") {
+    return true;
+  }
+  return false;
+}
+async function inspectPotentialModuleRoot(absolutePath) {
+  let sourceFileCount = 0;
+  let hasPublicEntrypoint = false;
+  const queue = [{ absolutePath, depth: 0 }];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    let entries;
+    try {
+      entries = await import_node_fs.promises.readdir(current.absolutePath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path.join(current.absolutePath, entry.name);
+      if (entry.isDirectory()) {
+        if (current.depth >= 2 || isIgnoredDirectoryName(entry.name)) {
+          continue;
+        }
+        queue.push({ absolutePath: entryPath, depth: current.depth + 1 });
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (sourceFileExtensions.has(path.extname(entry.name).toLowerCase())) {
+        sourceFileCount += 1;
+      }
+      if (current.depth === 0 && publicEntrypointNames.has(entry.name.toLowerCase())) {
+        hasPublicEntrypoint = true;
+      }
+    }
+  }
+  return { sourceFileCount, hasPublicEntrypoint };
+}
+async function addModuleIfStrongCandidate(workspaceRoot, discovered, sourcePath, moduleId, options) {
+  const normalizedSourcePath = normalizePath(sourcePath);
+  const name = normalizedSourcePath.split("/").pop() ?? moduleId;
+  if (options?.allowNoisyNames !== true && isNoisyModuleName(name)) {
+    return;
+  }
+  const absolutePath = path.join(workspaceRoot, ...normalizedSourcePath.split("/"));
+  const inspected = await inspectPotentialModuleRoot(absolutePath);
+  const hasStrongEvidence = inspected.sourceFileCount >= 2 || inspected.hasPublicEntrypoint || isKnownNestedModuleRoot(normalizedSourcePath);
+  if (options?.requireStrongEvidence !== false && !hasStrongEvidence) {
+    return;
+  }
+  const normalizedModuleId = normalizePath(moduleId || toModuleIdFromPath(normalizedSourcePath, options?.fallbackRoot));
+  if (!normalizedModuleId || options?.allowNoisyNames !== true && isNoisyModuleName(normalizedModuleId.split("/").pop() ?? normalizedModuleId)) {
+    return;
+  }
+  if (!discovered.has(normalizedModuleId)) {
+    discovered.set(normalizedModuleId, {
+      moduleId: normalizedModuleId,
+      sourcePath: normalizedSourcePath
+    });
+  }
+}
+async function addChildrenFromRoot(workspaceRoot, discovered, rootRelativePath, options) {
+  const normalizedRoot = normalizePath(rootRelativePath);
+  const absoluteRoot = path.join(workspaceRoot, ...normalizedRoot.split("/"));
+  if (!await pathExists(absoluteRoot)) {
+    return;
+  }
+  const entries = (await import_node_fs.promises.readdir(absoluteRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && !isIgnoredDirectoryName(entry.name)).sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    const sourcePath = `${normalizedRoot}/${entry.name}`;
+    const moduleId = options?.includeParentPrefix && options.parentId ? `${options.parentId}/${entry.name}` : toModuleIdFromPath(sourcePath, normalizedRoot);
+    await addModuleIfStrongCandidate(workspaceRoot, discovered, sourcePath, moduleId, {
+      fallbackRoot: normalizedRoot,
+      ...options?.requireStrongEvidence !== void 0 ? { requireStrongEvidence: options.requireStrongEvidence } : {},
+      ...options?.allowNoisyNames !== void 0 ? { allowNoisyNames: options.allowNoisyNames } : {}
+    });
+  }
+}
+async function addMonorepoContainerModules(workspaceRoot, discovered, container) {
+  const absoluteContainer = path.join(workspaceRoot, container);
+  if (!await pathExists(absoluteContainer)) {
+    return;
+  }
+  const entries = (await import_node_fs.promises.readdir(absoluteContainer, { withFileTypes: true })).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && !isIgnoredDirectoryName(entry.name)).sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    const packagePath = `${container}/${entry.name}`;
+    await addModuleIfStrongCandidate(workspaceRoot, discovered, packagePath, entry.name, {
+      requireStrongEvidence: false
+    });
+    for (const sourceRoot of [
+      `${packagePath}/src`,
+      `${packagePath}/src/modules`,
+      `${packagePath}/src/features`,
+      `${packagePath}/src/domain`,
+      `${packagePath}/src/domains`,
+      `${packagePath}/src/application`,
+      `${packagePath}/src/infrastructure`
+    ]) {
+      await addChildrenFromRoot(workspaceRoot, discovered, sourceRoot, {
+        parentId: entry.name,
+        includeParentPrefix: true
+      });
+    }
+  }
+}
+async function discoverHierarchicalModuleRoots(workspaceRoot, modulesRootRelativePath = "src/modules") {
+  const discovered = /* @__PURE__ */ new Map();
+  await addChildrenFromRoot(workspaceRoot, discovered, normalizePath(modulesRootRelativePath), {
+    requireStrongEvidence: false,
+    allowNoisyNames: normalizePath(modulesRootRelativePath) === "src"
+  });
+  for (const root of [
+    "src/modules",
+    "src/features",
+    "src/domain",
+    "src/domains",
+    "src/application",
+    "src/infrastructure"
+  ]) {
+    await addChildrenFromRoot(workspaceRoot, discovered, root);
+  }
+  for (const container of ["packages", "apps", "services"]) {
+    await addMonorepoContainerModules(workspaceRoot, discovered, container);
+  }
+  return [...discovered.values()].sort((left, right) => left.moduleId.localeCompare(right.moduleId));
+}
 async function discoverModuleRoots(workspaceRoot, modulesRootRelativePath = "src/modules") {
+  const hierarchicalModules = await discoverHierarchicalModuleRoots(workspaceRoot, modulesRootRelativePath);
+  if (hierarchicalModules.length > 0) {
+    return new Map(
+      hierarchicalModules.map((entry) => [
+        entry.moduleId,
+        path.join(workspaceRoot, ...entry.sourcePath.split("/"))
+      ])
+    );
+  }
   const moduleDirectories = await listModuleDirectoryNames(workspaceRoot, modulesRootRelativePath);
   const modulesRoot = path.join(workspaceRoot, ...modulesRootRelativePath.split("/"));
   return new Map(
@@ -214497,7 +215111,8 @@ function buildArchitectureContract(base, overrides) {
 }
 function buildDefaultModuleContractPath(moduleName, contract) {
   const contractsRoot = resolveContractsRootFromContract(contract);
-  return `${contractsRoot}/${moduleName}.contract.json`;
+  const safeModuleName = moduleName.replace(/\\/g, "/").split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
+  return `${contractsRoot}/${safeModuleName}.contract.json`;
 }
 async function loadArchitectureContract(workspaceRoot) {
   const configPath = path7.join(workspaceRoot, ".archpilot", "architecture.json");
@@ -214628,8 +215243,63 @@ var DependencyRulesConfigError = class extends Error {
 function normalizePath2(filePath) {
   return filePath.replace(/\\/g, "/");
 }
-function getModulesRoot(workspaceRoot, modulesRootRelativePath = "src/modules") {
-  return path8.join(workspaceRoot, ...modulesRootRelativePath.split("/"));
+function toSafeContractModuleFileStem(moduleName) {
+  return normalizePath2(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
+}
+function normalizeAbsolutePath(filePath) {
+  return normalizePath2(path8.resolve(filePath)).toLowerCase();
+}
+function isPathInsideOrEqual(childPath, parentPath) {
+  const child = normalizeAbsolutePath(childPath);
+  const parent = normalizeAbsolutePath(parentPath);
+  return child === parent || child.startsWith(`${parent}/`);
+}
+function isParentChildModuleRelationship(leftModule, rightModule) {
+  if (leftModule === rightModule) {
+    return false;
+  }
+  return leftModule.startsWith(`${rightModule}/`) || rightModule.startsWith(`${leftModule}/`);
+}
+function isPeerModuleImport(dependencyImport) {
+  return !isParentChildModuleRelationship(
+    dependencyImport.sourceModule,
+    dependencyImport.targetModule
+  );
+}
+function filterPeerModuleImports(imports) {
+  return imports.filter(isPeerModuleImport);
+}
+function buildModuleHierarchyEdges(moduleIds) {
+  const moduleIdSet = new Set(moduleIds);
+  const edges = [];
+  for (const moduleId of moduleIds) {
+    const parentModule = moduleId.split("/").slice(0, -1).map((_, index, segments) => segments.slice(0, segments.length - index).join("/")).find((candidate) => moduleIdSet.has(candidate));
+    if (!parentModule) {
+      continue;
+    }
+    edges.push({ parentModule, childModule: moduleId });
+  }
+  return edges.sort((left, right) => {
+    const parentCompare = left.parentModule.localeCompare(right.parentModule);
+    if (parentCompare !== 0) {
+      return parentCompare;
+    }
+    return left.childModule.localeCompare(right.childModule);
+  });
+}
+function buildChildModulesByParent(hierarchyEdges) {
+  const byParent = /* @__PURE__ */ new Map();
+  for (const edge of hierarchyEdges) {
+    const children = byParent.get(edge.parentModule) ?? /* @__PURE__ */ new Set();
+    children.add(edge.childModule);
+    byParent.set(edge.parentModule, children);
+  }
+  return new Map(
+    [...byParent.entries()].map(([parentModule, childModules]) => [
+      parentModule,
+      sortUnique2(childModules)
+    ])
+  );
 }
 function getScriptKind(filePath) {
   const extension = path8.extname(filePath).toLowerCase();
@@ -214670,6 +215340,37 @@ async function readTextFileIfExists2(filePath) {
     return void 0;
   }
 }
+async function readPackageName(packageJsonPath) {
+  const contents = await readTextFileIfExists2(packageJsonPath);
+  if (!contents) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(contents);
+    return typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function buildWorkspacePackageAliasMap(moduleRoots) {
+  const aliases = [];
+  for (const [moduleId, moduleRoot] of [...moduleRoots.entries()].sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    const packageName = await readPackageName(path8.join(moduleRoot, "package.json"));
+    if (!packageName) {
+      continue;
+    }
+    aliases.push({ packageName, moduleId, moduleRoot });
+  }
+  return aliases.sort((left, right) => {
+    const lengthCompare = right.packageName.length - left.packageName.length;
+    if (lengthCompare !== 0) {
+      return lengthCompare;
+    }
+    return left.packageName.localeCompare(right.packageName);
+  });
+}
 function validateDependencyModuleRules(moduleName, value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new DependencyRulesConfigError(
@@ -215143,7 +215844,32 @@ async function resolveImportPath(basePath, adapter) {
   }
   return void 0;
 }
-async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, sourceFilePath, importSpecifier, adapter) {
+function resolvePackageAliasRemainder(packageName, importSpecifier) {
+  if (importSpecifier === packageName) {
+    return "";
+  }
+  if (importSpecifier.startsWith(`${packageName}/`)) {
+    return importSpecifier.slice(packageName.length + 1);
+  }
+  return void 0;
+}
+async function resolveWorkspacePackageImportPath(importSpecifier, workspacePackageAliases, adapter) {
+  const packageAlias = workspacePackageAliases.map((alias2) => ({
+    alias: alias2,
+    remainder: resolvePackageAliasRemainder(alias2.packageName, importSpecifier)
+  })).find(
+    (candidate) => candidate.remainder !== void 0
+  );
+  if (!packageAlias) {
+    return void 0;
+  }
+  const { alias, remainder } = packageAlias;
+  if (remainder.length === 0) {
+    return resolveImportPath(alias.moduleRoot, adapter);
+  }
+  return void 0;
+}
+async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, sourceFilePath, importSpecifier, adapter) {
   let basePath;
   const normalizedModulesRoot = normalizePath2(modulesRootRelativePath).replace(/^\/+/, "");
   if (usesJavaImportParser(adapter) && !importSpecifier.startsWith(".")) {
@@ -215198,6 +215924,22 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
     basePath = path8.join(workspaceRoot, importSpecifier.slice(1));
   } else if (normalizedModulesRoot.startsWith("src/") && importSpecifier.startsWith(`${normalizedModulesRoot.slice("src/".length)}/`)) {
     basePath = path8.join(workspaceRoot, "src", importSpecifier);
+  } else {
+    const workspacePackageImportPath = await resolveWorkspacePackageImportPath(
+      importSpecifier,
+      workspacePackageAliases,
+      adapter
+    );
+    if (workspacePackageImportPath) {
+      basePath = workspacePackageImportPath;
+    } else {
+      const moduleImportTarget = [...moduleRoots.entries()].filter(([moduleId]) => importSpecifier === moduleId || importSpecifier.startsWith(`${moduleId}/`)).sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]))[0];
+      if (moduleImportTarget) {
+        const [moduleId, moduleRoot] = moduleImportTarget;
+        const remainder = importSpecifier === moduleId ? "" : importSpecifier.slice(moduleId.length + 1);
+        basePath = path8.join(moduleRoot, ...remainder.split("/").filter((segment) => segment.length > 0));
+      }
+    }
   }
   if (!basePath) {
     return void 0;
@@ -215206,17 +215948,8 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   if (!resolvedPath) {
     return void 0;
   }
-  const modulesRoot = getModulesRoot(workspaceRoot, modulesRootRelativePath);
-  const relativeToModulesRoot = normalizePath2(path8.relative(modulesRoot, resolvedPath));
-  if (relativeToModulesRoot === "" || relativeToModulesRoot.startsWith("../") || relativeToModulesRoot.startsWith("..\\")) {
-    return void 0;
-  }
-  const segments = relativeToModulesRoot.split("/");
-  if (segments.length === 0) {
-    return void 0;
-  }
-  const targetModule = segments[0];
-  if (!moduleRoots.has(targetModule)) {
+  const targetModuleEntry = [...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(
       normalizePath2(path8.relative(workspaceRoot, resolvedPath))
     );
@@ -215229,7 +215962,11 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
       isPublicImport: true
     };
   }
-  const targetSubPath = segments.slice(1).join("/");
+  const [targetModule, targetModuleRoot] = targetModuleEntry;
+  const targetSubPath = normalizePath2(path8.relative(targetModuleRoot, resolvedPath));
+  if (targetSubPath === "" || targetSubPath.startsWith("../") || targetSubPath.startsWith("..\\")) {
+    return void 0;
+  }
   const indexEntrypointCandidates = adapter.dependencyParsingFileExtensions.map(
     (extension) => `index${extension}`
   );
@@ -215242,7 +215979,7 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
     isPublicImport
   };
 }
-async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, adapter, options) {
+async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath, moduleRoots, explicitStandaloneModuleByPath, workspacePackageAliases, adapter, options) {
   const imports = [];
   const includeTestFiles = options?.includeTestFiles === true;
   if (!supportsDependencyImportParsing(adapter)) {
@@ -215251,7 +215988,10 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
   for (const [moduleName, moduleRoot] of [...moduleRoots.entries()].sort(
     ([left], [right]) => left.localeCompare(right)
   )) {
-    const sourceFiles = await collectSourceFiles(moduleRoot, adapter);
+    const childModuleRoots = [...moduleRoots.entries()].filter(([childModuleName, childModuleRoot]) => childModuleName !== moduleName && isPathInsideOrEqual(childModuleRoot, moduleRoot)).map(([, childModuleRoot]) => childModuleRoot);
+    const sourceFiles = (await collectSourceFiles(moduleRoot, adapter)).filter(
+      (sourceFile) => !childModuleRoots.some((childModuleRoot) => isPathInsideOrEqual(sourceFile, childModuleRoot))
+    );
     for (const sourceFilePath of sourceFiles) {
       const sourceFileRelativePath = normalizePath2(
         path8.relative(workspaceRoot, sourceFilePath)
@@ -215274,6 +216014,7 @@ async function collectCrossModuleImports(workspaceRoot, modulesRootRelativePath,
           modulesRootRelativePath,
           moduleRoots,
           explicitStandaloneModuleByPath,
+          workspacePackageAliases,
           sourceFilePath,
           importReference.specifier,
           adapter
@@ -215419,7 +216160,7 @@ async function loadModuleArchitectureContract(workspaceRoot, architectureContrac
   const registryEntry = architectureContract.modules[moduleName];
   const contractPath = registryEntry?.contract ?? path8.posix.join(
     resolveContractsRootFromContract(architectureContract),
-    `${moduleName}.contract.json`
+    `${toSafeContractModuleFileStem(moduleName)}.contract.json`
   );
   const fullContractPath = path8.join(workspaceRoot, ...contractPath.split("/"));
   const content = await readTextFileIfExists2(fullContractPath);
@@ -215566,6 +216307,7 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
     workspaceRoot,
     architectureContract
   );
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
   const moduleIds = sortUnique2([...moduleRoots.keys(), ...explicitStandaloneModuleByPath.values()]);
   const registeredModuleIds = new Set(moduleIds);
   const imports = await collectCrossModuleImports(
@@ -215573,9 +216315,11 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
     modulesRoot,
     moduleRoots,
     explicitStandaloneModuleByPath,
+    workspacePackageAliases,
     adapter
   );
-  const actualBySource = buildActualImportedModuleSetBySource(imports, registeredModuleIds);
+  const peerImports = filterPeerModuleImports(imports);
+  const actualBySource = buildActualImportedModuleSetBySource(peerImports, registeredModuleIds);
   const moduleContractCache = /* @__PURE__ */ new Map();
   const declaredBySource = /* @__PURE__ */ new Map();
   const hasContractByModule = /* @__PURE__ */ new Map();
@@ -215593,7 +216337,7 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
         new Set(
           sortUnique2(
             sourceContract.contract.dependsOn.filter(
-              (dependencyModule) => registeredModuleIds.has(dependencyModule)
+              (dependencyModule) => registeredModuleIds.has(dependencyModule) && !isParentChildModuleRelationship(moduleId, dependencyModule)
             )
           )
         )
@@ -215605,6 +216349,11 @@ 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])
+  );
   return {
     modules: moduleIds.map((moduleId) => {
       const declaredDependencies = sortUnique2(declaredBySource.get(moduleId) ?? []);
@@ -215618,6 +216367,8 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
       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) ?? [],
@@ -215625,7 +216376,8 @@ async function buildDependencyGraphSummary(workspaceRoot, architectureContract,
         unusedDeclaredDependencies,
         undeclaredActualDependencies
       };
-    })
+    }),
+    hierarchyEdges
   };
 }
 async function validateDependencyContractBoundaries(workspaceRoot, architectureContract, options) {
@@ -215639,19 +216391,22 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     workspaceRoot,
     architectureContract
   );
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
   const imports = await collectCrossModuleImports(
     workspaceRoot,
     modulesRoot,
     moduleRoots,
     explicitStandaloneModuleByPath,
+    workspacePackageAliases,
     adapter
   );
+  const peerImports = filterPeerModuleImports(imports);
   const findings = [];
   const moduleContractCache = /* @__PURE__ */ new Map();
   if (options.checkDeclaredDependencies) {
     const failures = [];
     const skippedFindings = /* @__PURE__ */ new Map();
-    for (const dependencyImport of imports) {
+    for (const dependencyImport of peerImports) {
       const sourceContract = await loadModuleArchitectureContract(
         workspaceRoot,
         architectureContract,
@@ -215723,7 +216478,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     }
     if (failures.length > 0) {
       findings.push(...failures);
-    } else if (imports.length === 0) {
+    } else if (peerImports.length === 0) {
       findings.push({
         result: makeValidationResult(
           "AP-DEP-004",
@@ -215748,7 +216503,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
   if (options.checkPublicSurfaceImports) {
     const failures = [];
     const skippedFindings = /* @__PURE__ */ new Map();
-    for (const dependencyImport of imports) {
+    for (const dependencyImport of peerImports) {
       const sourceContract = await loadModuleArchitectureContract(
         workspaceRoot,
         architectureContract,
@@ -215815,17 +216570,18 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
         }
         continue;
       }
-      if (targetContract.contract.publicEntrypoints.length > 0 && normalizePath2(dependencyImport.resolvedTargetRelativePath) !== buildModuleIndexEntrypointPath(
-        modulesRoot,
-        dependencyImport.targetModule,
-        adapter
+      if (targetContract.contract.publicEntrypoints.length > 0 && !isImportWithinPublicEntrypoints(
+        dependencyImport.resolvedTargetRelativePath,
+        targetContract.contract.publicEntrypoints
       )) {
+        const expectedEntrypoint = targetContract.contract.publicEntrypoints[0] ?? buildModuleIndexEntrypointPath(modulesRoot, dependencyImport.targetModule, adapter);
+        const publicEntrypointLabel = expectedEntrypoint.endsWith("/index.ts") ? "index.ts public entrypoint" : "public entrypoint";
         failures.push({
           result: makeValidationResult(
             "AP-DEP-005",
             "error",
             false,
-            `Module '${dependencyImport.sourceModule}' must import module '${dependencyImport.targetModule}' via its index.ts public entrypoint: ${buildModuleIndexEntrypointPath(modulesRoot, dependencyImport.targetModule, adapter)}.`,
+            `Module '${dependencyImport.sourceModule}' must import module '${dependencyImport.targetModule}' via its ${publicEntrypointLabel}: ${expectedEntrypoint}.`,
             {
               findingType: "module-dependency",
               module: dependencyImport.sourceModule,
@@ -215866,7 +216622,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
     }
     if (failures.length > 0) {
       findings.push(...failures);
-    } else if (imports.length === 0) {
+    } else if (peerImports.length === 0) {
       findings.push({
         result: makeValidationResult(
           "AP-DEP-005",
@@ -215895,7 +216651,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
       ...explicitStandaloneModuleByPath.values()
     ]);
     const importedBySource = buildActualImportedModuleSetBySource(
-      imports,
+      peerImports,
       registeredModuleIds
     );
     for (const moduleName of [...registeredModuleIds].sort(
@@ -215910,7 +216666,9 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
       if (sourceContract.status !== "ok" || !sourceContract.contract) {
         continue;
       }
-      const declaredDependencies = [...sourceContract.contract.dependsOn].filter((dependencyModule) => registeredModuleIds.has(dependencyModule)).sort((left, right) => left.localeCompare(right));
+      const declaredDependencies = [...sourceContract.contract.dependsOn].filter(
+        (dependencyModule) => registeredModuleIds.has(dependencyModule) && !isParentChildModuleRelationship(moduleName, dependencyModule)
+      ).sort((left, right) => left.localeCompare(right));
       if (declaredDependencies.length === 0) {
         continue;
       }
@@ -215965,13 +216723,16 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
     workspaceRoot,
     parsedArchitectureContract
   );
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
   const imports = await collectCrossModuleImports(
     workspaceRoot,
     modulesRootRelativePath,
     moduleRoots,
     explicitStandaloneModuleByPath,
+    workspacePackageAliases,
     adapter
   );
+  const peerImports = filterPeerModuleImports(imports);
   const findings = [];
   let dependencyRules;
   let dependencyRulesSkipReason;
@@ -215992,7 +216753,7 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
     }
   }
   if (options.checkCircularDependencies) {
-    const cycles = detectCircularDependencies([...moduleRoots.keys()], imports);
+    const cycles = detectCircularDependencies([...moduleRoots.keys()], peerImports);
     if (cycles.length === 0) {
       findings.push({
         result: makeValidationResult(
@@ -216024,7 +216785,7 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         })
       );
     } else {
-      const violations = imports.filter((dependencyImport) => {
+      const violations = peerImports.filter((dependencyImport) => {
         const moduleRules = dependencyRules.modules[dependencyImport.sourceModule];
         if (!moduleRules) {
           return false;
@@ -216076,7 +216837,7 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         })
       );
     } else {
-      const violations = imports.filter((dependencyImport) => {
+      const violations = peerImports.filter((dependencyImport) => {
         const moduleRules = dependencyRules.modules[dependencyImport.sourceModule];
         return moduleRules?.publicEntrypointsOnly === true && !dependencyImport.isPublicImport;
       });
@@ -216124,6 +216885,7 @@ async function buildModuleDependencyGraphSnapshot(workspaceRoot, options) {
     workspaceRoot,
     parsedArchitectureContract
   );
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
   const discoveredModules = sortUnique2([
     ...moduleRoots.keys(),
     ...explicitStandaloneModuleByPath.values()
@@ -216136,9 +216898,10 @@ async function buildModuleDependencyGraphSnapshot(workspaceRoot, options) {
     modulesRootRelativePath,
     moduleRoots,
     explicitStandaloneModuleByPath,
+    workspacePackageAliases,
     adapter
   );
-  const imports = allImports.filter(
+  const imports = filterPeerModuleImports(allImports).filter(
     (dependencyImport) => moduleSet.has(dependencyImport.sourceModule) && moduleSet.has(dependencyImport.targetModule)
   ).sort((left, right) => {
     const sourceCompare = left.sourceModule.localeCompare(right.sourceModule);
@@ -216191,6 +216954,7 @@ async function buildModuleDependencyGraphSnapshot(workspaceRoot, options) {
   return {
     modules,
     edges,
+    hierarchyEdges: buildModuleHierarchyEdges(modules),
     cycles,
     imports
   };
@@ -219592,11 +220356,11 @@ src/
   },
   DEP_ISOLATED_MODULE_DETECTED: {
     id: ValidationRuleIds.DEP_ISOLATED_MODULE_DETECTED,
-    title: "Isolated module detected",
+    title: "Potential orphan module detected",
     category: "dependency",
     defaultSeverity: "warning",
-    description: "Checks whether a registered module has no declared or actual inbound/outbound module dependencies.",
-    recommendedFix: "Connect the module to the architecture through legitimate dependencies, or remove it if it is unused."
+    description: "Checks whether a registered module has no peer-module dependencies and little evidence of intentional architectural use.",
+    recommendedFix: "Add intentional-use evidence such as a contract, README, public entrypoint, package entrypoint, or remove the module if it is stale."
   },
   DEP_TRANSITIVE_CIRCULAR_MODULE_DEPENDENCY: {
     id: ValidationRuleIds.DEP_TRANSITIVE_CIRCULAR_MODULE_DEPENDENCY,
@@ -220815,8 +221579,17 @@ async function validateArchitectureStyle(workspaceRoot, contract, validationConf
     const modulesRootRelativePath2 = await getConfiguredModulesRoot(workspaceRoot, contract);
     const modulesRoot = path21.join(workspaceRoot, ...modulesRootRelativePath2.split("/"));
     if (await pathExists7(modulesRoot)) {
-      const moduleEntries = await import_node_fs20.promises.readdir(modulesRoot, { withFileTypes: true });
-      const moduleDirectories2 = moduleEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+      const hierarchicalModules = await discoverHierarchicalModuleRoots(
+        workspaceRoot,
+        modulesRootRelativePath2
+      );
+      const moduleDirectories2 = hierarchicalModules.length > 0 ? hierarchicalModules.map((entry) => ({
+        moduleName: entry.moduleId,
+        sourcePath: entry.sourcePath
+      })) : (await import_node_fs20.promises.readdir(modulesRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => ({
+        moduleName: entry.name,
+        sourcePath: `${modulesRootRelativePath2}/${entry.name}`
+      })).sort((left, right) => left.moduleName.localeCompare(right.moduleName));
       const dependencySummary = await buildDependencyGraphSummary(workspaceRoot, contract, {
         modulesRootRelativePath: modulesRootRelativePath2
       });
@@ -220824,8 +221597,9 @@ async function validateArchitectureStyle(workspaceRoot, contract, validationConf
         dependencySummary.modules.filter((moduleSummary) => moduleSummary.inboundDeclaredFrom.length > 0).map((moduleSummary) => moduleSummary.module)
       );
       const incompleteModules = [];
-      for (const moduleName of moduleDirectories2) {
-        const moduleDir = path21.join(modulesRoot, moduleName);
+      for (const moduleDirectory of moduleDirectories2) {
+        const moduleName = moduleDirectory.moduleName;
+        const moduleDir = path21.join(workspaceRoot, ...moduleDirectory.sourcePath.split("/"));
         const readmeExists = await pathExists7(path21.join(moduleDir, "README.md"));
         const indexExists = await pathExists7(path21.join(moduleDir, "index.ts"));
         const registryPublicEntrypoints = (contract.modules[moduleName]?.publicEntrypoints ?? []).filter((entry) => typeof entry === "string").map((entry) => normalizeEntrypoint(entry));
@@ -220954,18 +221728,111 @@ async function validateDependencyGraphIsolation(workspaceRoot, contract, depende
     return [];
   }
   const isolatedResults = [];
-  const isolationExemptInfrastructureModules = /* @__PURE__ */ new Set(["ci", "policy", "validation"]);
+  const sourceFileExtensions4 = /* @__PURE__ */ new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+    ".py",
+    ".go",
+    ".java",
+    ".kt",
+    ".kts",
+    ".cs",
+    ".php",
+    ".rb",
+    ".vue",
+    ".svelte"
+  ]);
   const isTestLikeModule = (moduleName) => {
     const normalized = moduleName.toLowerCase();
     return normalized === "test" || normalized === "tests" || normalized.endsWith("-test") || normalized.endsWith("-tests");
   };
+  const collectModuleSourceEvidence2 = async (directoryPath) => {
+    let entries;
+    try {
+      entries = await import_node_fs20.promises.readdir(directoryPath, { withFileTypes: true });
+    } catch {
+      return { sourceFileCount: 0, hasReadme: false, hasEntrypointFile: false };
+    }
+    let sourceFileCount = 0;
+    let hasReadme = false;
+    let hasEntrypointFile = false;
+    for (const entry of entries) {
+      const fullPath = path21.join(directoryPath, entry.name);
+      if (entry.isDirectory()) {
+        if (["node_modules", "dist", "out", "build", "coverage", ".git"].includes(entry.name)) {
+          continue;
+        }
+        const nested = await collectModuleSourceEvidence2(fullPath);
+        sourceFileCount += nested.sourceFileCount;
+        hasReadme ||= nested.hasReadme;
+        hasEntrypointFile ||= nested.hasEntrypointFile;
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const lowerName = entry.name.toLowerCase();
+      if (lowerName === "readme.md" || lowerName === "readme.mdx") {
+        hasReadme = true;
+      }
+      if (/^(index|main|app|extension|cli)\.[cm]?[jt]sx?$/iu.test(entry.name)) {
+        hasEntrypointFile = true;
+      }
+      if (sourceFileExtensions4.has(path21.extname(entry.name).toLowerCase())) {
+        sourceFileCount += 1;
+      }
+    }
+    return { sourceFileCount, hasReadme, hasEntrypointFile };
+  };
+  const readPackageJsonIfExists2 = async (moduleDirectoryPath) => {
+    const content = await readTextFileIfExists3(path21.join(moduleDirectoryPath, "package.json"));
+    if (!content) {
+      return void 0;
+    }
+    try {
+      const parsed = JSON.parse(content);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const hasPackageEntrypoint2 = async (moduleDirectoryPath) => {
+    const packageJson = await readPackageJsonIfExists2(moduleDirectoryPath);
+    if (!packageJson) {
+      return false;
+    }
+    return ["main", "module", "browser", "types", "bin", "exports"].some(
+      (field) => packageJson[field] !== void 0
+    );
+  };
+  const hasKnownBoundaryRole2 = (moduleName) => {
+    const normalized = moduleName.toLowerCase();
+    const compact = normalized.replace(/[-_/]/gu, "");
+    const segments = normalized.split(/[/-]/u);
+    return ["adr", "ci", "compliance", "config", "governance", "policy", "validation", "smartinit"].some(
+      (role) => compact.includes(role) || segments.includes(role)
+    );
+  };
+  const hasConfiguredPublicEntrypoint2 = (moduleName) => {
+    const publicEntrypoints = contract.modules[moduleName]?.publicEntrypoints;
+    return Array.isArray(publicEntrypoints) && publicEntrypoints.some(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    );
+  };
+  const hasIntentionalIndependentEvidence2 = async (moduleSummary, moduleDirectoryPath) => {
+    const sourceEvidence = await collectModuleSourceEvidence2(moduleDirectoryPath);
+    return moduleSummary.hasContract || hasConfiguredPublicEntrypoint2(moduleSummary.module) || sourceEvidence.hasReadme || sourceEvidence.hasEntrypointFile || await hasPackageEntrypoint2(moduleDirectoryPath) || moduleSummary.childModules.length > 0 || moduleSummary.parentModule !== void 0 && moduleSummary.childModules.length === 0 && sourceEvidence.sourceFileCount > 0 || hasKnownBoundaryRole2(moduleSummary.module) || sourceEvidence.sourceFileCount >= 2;
+  };
   for (const moduleSummary of dependencyGraphSummary.modules) {
     if (isTestLikeModule(moduleSummary.module)) {
       continue;
     }
-    if (isolationExemptInfrastructureModules.has(moduleSummary.module.toLowerCase())) {
-      continue;
-    }
     const registryEntry = contract.modules[moduleSummary.module];
     if (!registryEntry?.path) {
       continue;
@@ -220979,11 +221846,14 @@ async function validateDependencyGraphIsolation(workspaceRoot, contract, depende
     if (!isIsolated) {
       continue;
     }
+    if (await hasIntentionalIndependentEvidence2(moduleSummary, moduleDirectoryPath)) {
+      continue;
+    }
     isolatedResults.push({
       id: ValidationRuleIds.DEP_ISOLATED_MODULE_DETECTED,
       severity: "warning",
       passed: false,
-      message: `Module '${moduleSummary.module}' is isolated: it has no declared or actual inbound/outbound module dependencies.`,
+      message: `Module '${moduleSummary.module}' is a potential orphan: it has no declared or actual inbound/outbound module dependencies and little evidence of intentional architectural use.`,
       findingType: "module-dependency",
       module: moduleSummary.module
     });
@@ -220996,7 +221866,7 @@ async function validateDependencyGraphIsolation(workspaceRoot, contract, depende
       id: ValidationRuleIds.DEP_ISOLATED_MODULE_DETECTED,
       severity: "warning",
       passed: true,
-      message: "No isolated modules detected among registered modules with existing registry paths."
+      message: "No potential orphan modules detected among registered modules with existing registry paths."
     }
   ];
 }
@@ -221778,7 +222648,10 @@ function filterDependencyGraphSummaryByModuleScope(dependencyGraphSummary, modul
     )
   }));
   return {
-    modules: scopedModules
+    modules: scopedModules,
+    hierarchyEdges: dependencyGraphSummary.hierarchyEdges.filter(
+      (edge) => scopeSet.has(edge.parentModule) && scopeSet.has(edge.childModule)
+    )
   };
 }
 async function runArchitectureValidationForWorkspace(workspaceRoot, options) {
@@ -224779,9 +225652,32 @@ async function readTextFileIfExists4(filePath) {
     return void 0;
   }
 }
+var sourceFileExtensions2 = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".py",
+  ".go",
+  ".java",
+  ".kt",
+  ".kts",
+  ".cs",
+  ".php",
+  ".rb",
+  ".vue",
+  ".svelte"
+]);
 function sortUnique3(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
+function toSafeContractModuleFileStem2(moduleName) {
+  return normalizePath5(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
+}
 function getModuleRegistry(contract) {
   const modules = contract?.modules;
   if (!modules || typeof modules !== "object" || Array.isArray(modules)) {
@@ -224792,6 +225688,83 @@ function getModuleRegistry(contract) {
 function normalizePublicEntrypointList(entries) {
   return sortUnique3(entries.map((entry) => normalizePath5(entry.trim())).filter((entry) => entry.length > 0));
 }
+function hasConfiguredPublicEntrypoint(registryEntry) {
+  return Array.isArray(registryEntry?.publicEntrypoints) && registryEntry.publicEntrypoints.some(
+    (entry) => typeof entry === "string" && entry.trim().length > 0
+  );
+}
+async function readPackageJsonIfExists(moduleDirectoryPath) {
+  const content = await readTextFileIfExists4(path26.join(moduleDirectoryPath, "package.json"));
+  if (!content) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function collectModuleSourceEvidence(directoryPath) {
+  let entries;
+  try {
+    entries = await import_node_fs24.promises.readdir(directoryPath, { withFileTypes: true });
+  } catch {
+    return { sourceFileCount: 0, hasReadme: false, hasEntrypointFile: false };
+  }
+  let sourceFileCount = 0;
+  let hasReadme = false;
+  let hasEntrypointFile = false;
+  for (const entry of entries) {
+    const fullPath = path26.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      if (["node_modules", "dist", "out", "build", "coverage", ".git"].includes(entry.name)) {
+        continue;
+      }
+      const nested = await collectModuleSourceEvidence(fullPath);
+      sourceFileCount += nested.sourceFileCount;
+      hasReadme ||= nested.hasReadme;
+      hasEntrypointFile ||= nested.hasEntrypointFile;
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    const lowerName = entry.name.toLowerCase();
+    if (lowerName === "readme.md" || lowerName === "readme.mdx") {
+      hasReadme = true;
+    }
+    if (/^(index|main|app|extension|cli)\.[cm]?[jt]sx?$/iu.test(entry.name)) {
+      hasEntrypointFile = true;
+    }
+    if (sourceFileExtensions2.has(path26.extname(entry.name).toLowerCase())) {
+      sourceFileCount += 1;
+    }
+  }
+  return { sourceFileCount, hasReadme, hasEntrypointFile };
+}
+function hasKnownBoundaryRole(moduleName) {
+  const normalized = moduleName.toLowerCase();
+  const compact = normalized.replace(/[-_/]/gu, "");
+  const segments = normalized.split(/[/-]/u);
+  return ["adr", "ci", "compliance", "config", "governance", "policy", "validation", "smartinit"].some(
+    (role) => compact.includes(role) || segments.includes(role)
+  );
+}
+async function hasPackageEntrypoint(moduleDirectoryPath) {
+  const packageJson = await readPackageJsonIfExists(moduleDirectoryPath);
+  if (!packageJson) {
+    return false;
+  }
+  return ["main", "module", "browser", "types", "bin", "exports"].some(
+    (field) => packageJson[field] !== void 0
+  );
+}
+async function hasIntentionalIndependentEvidence(args) {
+  const moduleDirectoryPath = path26.join(args.workspaceRoot, ...args.moduleEntry.sourcePath.split("/"));
+  const evidence = await collectModuleSourceEvidence(moduleDirectoryPath);
+  return args.moduleEntry.contractExists || args.moduleEntry.hasPublicEntrypoint === true || evidence.hasReadme || evidence.hasEntrypointFile || await hasPackageEntrypoint(moduleDirectoryPath) || args.hasChildren || args.isLeafChild && evidence.sourceFileCount > 0 || hasKnownBoundaryRole(args.moduleEntry.moduleName) || evidence.sourceFileCount >= 2;
+}
 async function loadModuleContractPublicEntrypoints(workspaceRoot, contractPath) {
   const fullContractPath = path26.join(workspaceRoot, ...contractPath.split("/"));
   const content = await readTextFileIfExists4(fullContractPath);
@@ -224832,7 +225805,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
   const discovered = [];
   const discoveredNames = /* @__PURE__ */ new Set();
   const toContractPath = (moduleName, registryEntry) => normalizePath5(
-    typeof registryEntry?.contract === "string" ? registryEntry.contract : `${contractsRoot}/${moduleName}.contract.json`
+    typeof registryEntry?.contract === "string" ? registryEntry.contract : `${contractsRoot}/${toSafeContractModuleFileStem2(moduleName)}.contract.json`
   );
   const resolveMissingPublicEntrypointAlignment = async (registryEntry, contractPath) => {
     if (!Array.isArray(registryEntry?.publicEntrypoints)) {
@@ -224876,7 +225849,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
       continue;
     }
     const contractPath = normalizePath5(
-      typeof registryEntry.contract === "string" ? registryEntry.contract : `${contractsRoot}/${moduleName}.contract.json`
+      typeof registryEntry.contract === "string" ? registryEntry.contract : `${contractsRoot}/${toSafeContractModuleFileStem2(moduleName)}.contract.json`
     );
     const contractExists = await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")));
     const missingPublicEntrypointAlignment = await resolveMissingPublicEntrypointAlignment(
@@ -224891,6 +225864,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
       ...resolveModuleScopeForPath(workspaceRoot, normalizedSourcePath, contract) ? { scope: resolveModuleScopeForPath(workspaceRoot, normalizedSourcePath, contract) } : {},
       contractPath,
       contractExists,
+      hasPublicEntrypoint: hasConfiguredPublicEntrypoint(registryEntry),
       ...missingPublicEntrypointAlignment !== void 0 ? { missingPublicEntrypointAlignment } : {}
     });
     discoveredNames.add(moduleName);
@@ -224915,18 +225889,56 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
       ...resolveModuleScopeForPath(workspaceRoot, sourcePath, contract) ? { scope: resolveModuleScopeForPath(workspaceRoot, sourcePath, contract) } : {},
       contractPath,
       contractExists,
+      hasPublicEntrypoint: hasConfiguredPublicEntrypoint(registryEntry),
       ...missingPublicEntrypointAlignment !== void 0 ? { missingPublicEntrypointAlignment } : {}
     });
     discoveredNames.add(moduleName);
   }
+  for (const moduleRoot of await discoverHierarchicalModuleRoots(workspaceRoot, normalizedModulesRoot)) {
+    if (discoveredNames.has(moduleRoot.moduleId)) {
+      continue;
+    }
+    const registryEntry = moduleRegistry[moduleRoot.moduleId];
+    const contractPath = toContractPath(moduleRoot.moduleId, registryEntry);
+    const contractExists = await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")));
+    const missingPublicEntrypointAlignment = await resolveMissingPublicEntrypointAlignment(
+      registryEntry,
+      contractPath
+    );
+    discovered.push({
+      moduleName: moduleRoot.moduleId,
+      sourcePath: moduleRoot.sourcePath,
+      discoverySource: "architecture.json",
+      sourcePathExists: true,
+      ...resolveModuleScopeForPath(workspaceRoot, moduleRoot.sourcePath, contract) ? { scope: resolveModuleScopeForPath(workspaceRoot, moduleRoot.sourcePath, contract) } : {},
+      contractPath,
+      contractExists,
+      hasPublicEntrypoint: hasConfiguredPublicEntrypoint(registryEntry),
+      ...missingPublicEntrypointAlignment !== void 0 ? { missingPublicEntrypointAlignment } : {}
+    });
+    discoveredNames.add(moduleRoot.moduleId);
+  }
   return discovered.sort((left, right) => left.moduleName.localeCompare(right.moduleName));
 }
 async function discoverModulesFromFallbackScan(workspaceRoot, modulesRoot = "src/modules", contractsRoot = ".archpilot/contracts") {
-  const moduleNames = await listModuleDirectoryNames(workspaceRoot, modulesRoot);
+  const hierarchicalModules = await discoverHierarchicalModuleRoots(workspaceRoot, modulesRoot);
+  const moduleNames = hierarchicalModules.length > 0 ? [] : await listModuleDirectoryNames(workspaceRoot, modulesRoot);
   const discovered = [];
+  for (const moduleRoot of hierarchicalModules) {
+    const contractPath = `${contractsRoot}/${toSafeContractModuleFileStem2(moduleRoot.moduleId)}.contract.json`;
+    discovered.push({
+      moduleName: moduleRoot.moduleId,
+      sourcePath: moduleRoot.sourcePath,
+      discoverySource: "inferred-scan",
+      sourcePathExists: true,
+      ...resolveModuleScopeForPath(workspaceRoot, moduleRoot.sourcePath) ? { scope: resolveModuleScopeForPath(workspaceRoot, moduleRoot.sourcePath) } : {},
+      contractPath,
+      contractExists: await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")))
+    });
+  }
   for (const moduleName of moduleNames) {
     const sourcePath = `${modulesRoot}/${moduleName}`;
-    const contractPath = `${contractsRoot}/${moduleName}.contract.json`;
+    const contractPath = `${contractsRoot}/${toSafeContractModuleFileStem2(moduleName)}.contract.json`;
     discovered.push({
       moduleName,
       sourcePath,
@@ -225024,14 +226036,39 @@ async function generateArchitectureMap(workspaceRoot, options) {
     moduleFilter: moduleIds
   });
   const edges = dependencySnapshot.edges.map((edge) => toArchitectureMapEdge(edge));
+  const hierarchyEdges = dependencySnapshot.hierarchyEdges;
   const parsedCycles = dependencySnapshot.cycles.map((cycle) => parseCycleString(cycle)).filter((cycle) => cycle.length > 1).sort((left, right) => left.join("->").localeCompare(right.join("->")));
   const incomingMap = buildIncomingMap(modules, edges);
   const outgoingMap = buildOutgoingMap(modules, edges);
   const cycleMembership = new Set(parsedCycles.flatMap((cycle) => cycle));
-  const hotspotSummary = modules.map((moduleEntry) => {
+  const hierarchyParentByChild = new Map(
+    hierarchyEdges.map((edge) => [edge.childModule, edge.parentModule])
+  );
+  const childModulesByParent = /* @__PURE__ */ new Map();
+  for (const edge of hierarchyEdges) {
+    const children = childModulesByParent.get(edge.parentModule) ?? [];
+    children.push(edge.childModule);
+    childModulesByParent.set(edge.parentModule, children);
+  }
+  const independentModuleNames = [];
+  const potentialOrphanModuleNames = [];
+  const hotspotSummary = await Promise.all(modules.map(async (moduleEntry) => {
     const incomingDependencyCount = incomingMap.get(moduleEntry.moduleName)?.length ?? 0;
     const outgoingDependencyCount = outgoingMap.get(moduleEntry.moduleName)?.length ?? 0;
-    const orphan = incomingDependencyCount === 0 && outgoingDependencyCount === 0;
+    const hasNoPeerUsage = incomingDependencyCount === 0 && outgoingDependencyCount === 0;
+    const hasIntentionalEvidence = hasNoPeerUsage ? await hasIntentionalIndependentEvidence({
+      workspaceRoot,
+      moduleEntry,
+      hasChildren: (childModulesByParent.get(moduleEntry.moduleName)?.length ?? 0) > 0,
+      isLeafChild: hierarchyParentByChild.has(moduleEntry.moduleName) && (childModulesByParent.get(moduleEntry.moduleName)?.length ?? 0) === 0
+    }) : false;
+    const orphan = hasNoPeerUsage && !hasIntentionalEvidence;
+    if (hasNoPeerUsage && hasIntentionalEvidence) {
+      independentModuleNames.push(moduleEntry.moduleName);
+    }
+    if (orphan) {
+      potentialOrphanModuleNames.push(moduleEntry.moduleName);
+    }
     return {
       moduleName: moduleEntry.moduleName,
       incomingDependencyCount,
@@ -225043,7 +226080,7 @@ async function generateArchitectureMap(workspaceRoot, options) {
         missingPublicEntrypointAlignment: moduleEntry.missingPublicEntrypointAlignment
       } : {}
     };
-  });
+  }));
   const mostDependedOnModules = sortRankedCounts(
     hotspotSummary.filter((entry) => entry.incomingDependencyCount > 0).map((entry) => ({
       moduleName: entry.moduleName,
@@ -225059,9 +226096,9 @@ async function generateArchitectureMap(workspaceRoot, options) {
   const modulesInCircularDependencies = sortUnique3(
     hotspotSummary.filter((entry) => entry.participatesInCycle).map((entry) => entry.moduleName)
   );
-  const orphanModules = sortUnique3(
-    hotspotSummary.filter((entry) => entry.orphan).map((entry) => entry.moduleName)
-  );
+  const independentModules = sortUnique3(independentModuleNames);
+  const potentialOrphanModules = sortUnique3(potentialOrphanModuleNames);
+  const orphanModules = potentialOrphanModules;
   const missingContracts = sortUnique3(
     hotspotSummary.filter((entry) => entry.missingContract).map((entry) => entry.moduleName)
   );
@@ -225084,11 +226121,14 @@ async function generateArchitectureMap(workspaceRoot, options) {
     modules,
     moduleHotspotSummary: hotspotSummary,
     edges,
+    hierarchyEdges,
     cycles: parsedCycles,
     hotspots: {
       mostDependedOnModules,
       highestOutgoingFanOutModules,
       modulesInCircularDependencies,
+      independentModules,
+      potentialOrphanModules,
       orphanModules,
       missingContracts,
       highlyConnectedModules,
@@ -225098,6 +226138,8 @@ async function generateArchitectureMap(workspaceRoot, options) {
       moduleCount: modules.length,
       edgeCount: edges.length,
       cycleCount: parsedCycles.length,
+      independentCount: independentModules.length,
+      potentialOrphanCount: potentialOrphanModules.length,
       orphanCount: orphanModules.length,
       highlyConnectedCount: highlyConnectedModules.length,
       missingContractCount: missingContracts.length
@@ -225113,6 +226155,11 @@ async function generateArchitectureMap(workspaceRoot, options) {
         importCount: edge.importCount,
         publicImportCount: edge.publicImportCount,
         nonPublicImportCount: edge.nonPublicImportCount
+      })),
+      hierarchyEdges: hierarchyEdges.map((edge) => ({
+        source: edge.parentModule,
+        target: edge.childModule,
+        relationship: "contains"
       }))
     },
     notes: {
@@ -230143,6 +231190,9 @@ async function pathExists13(targetPath) {
 function sortUnique12(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
+function toSafeContractModuleFileStem3(moduleName) {
+  return normalizePath11(moduleName).split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0).join(".");
+}
 function wildcardToRegex(pattern) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
   return new RegExp(`^${escaped.replace(/\*/g, ".*")}$`, "u");
@@ -230224,7 +231274,10 @@ function resolveContractPath(contract, moduleName) {
     return normalizePath11(configured);
   }
   return normalizePath11(
-    path44.posix.join(resolveContractsRootFromContract(contract), `${moduleName}.contract.json`)
+    path44.posix.join(
+      resolveContractsRootFromContract(contract),
+      `${toSafeContractModuleFileStem3(moduleName)}.contract.json`
+    )
   );
 }
 function createModuleContract(input2) {
@@ -230236,6 +231289,23 @@ function createModuleContract(input2) {
     exposedApis: []
   };
 }
+async function readExistingModuleContractPublicEntrypoints(workspaceRoot, contractPath) {
+  try {
+    const raw = await import_node_fs39.promises.readFile(toAbsolutePath(workspaceRoot, contractPath), {
+      encoding: "utf8"
+    });
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.publicEntrypoints)) {
+      return void 0;
+    }
+    if (parsed.publicEntrypoints.some((entry) => typeof entry !== "string")) {
+      return void 0;
+    }
+    return sortUnique12(parsed.publicEntrypoints.map((entry) => normalizePath11(entry)));
+  } catch {
+    return void 0;
+  }
+}
 function isRegistryEntryDifferent(input2) {
   const moduleRegistry = getModuleRegistry2(input2.contract);
   const existing = moduleRegistry[input2.moduleName] ?? {};
@@ -230262,7 +231332,15 @@ async function generateMissingModuleContracts(workspaceRoot) {
   )) {
     const contractPath = resolveContractPath(contract, moduleEntry.moduleName);
     const sourcePath = normalizePath11(moduleEntry.sourcePath);
-    const publicEntrypoints = await inferModulePublicEntrypoints(
+    const absoluteContractPath = toAbsolutePath(workspaceRoot, contractPath);
+    const contractExists = await pathExists13(absoluteContractPath);
+    const existingContractPublicEntrypoints = contractExists ? await readExistingModuleContractPublicEntrypoints(workspaceRoot, contractPath) : void 0;
+    const configuredPublicEntrypoints = !contractExists && Array.isArray(getModuleRegistry2(contract)[moduleEntry.moduleName]?.publicEntrypoints) ? sortUnique12(
+      getModuleRegistry2(contract)[moduleEntry.moduleName]?.publicEntrypoints?.map(
+        (entry) => normalizePath11(entry)
+      ) ?? []
+    ) : void 0;
+    const publicEntrypoints = existingContractPublicEntrypoints ?? configuredPublicEntrypoints ?? await inferModulePublicEntrypoints(
       workspaceRoot,
       sourcePath,
       adapter
@@ -230272,8 +231350,7 @@ async function generateMissingModuleContracts(workspaceRoot) {
       dependsOn: dependsOnBySource.get(moduleEntry.moduleName) ?? [],
       publicEntrypoints
     });
-    const absoluteContractPath = toAbsolutePath(workspaceRoot, contractPath);
-    if (await pathExists13(absoluteContractPath)) {
+    if (contractExists) {
       skippedExistingContracts.push(contractPath);
     } else {
       await import_node_fs39.promises.mkdir(path44.dirname(absoluteContractPath), { recursive: true });
@@ -231635,6 +232712,7 @@ var ignoredDirectoryNames2 = /* @__PURE__ */ new Set([
 ]);
 var backendStackIds = /* @__PURE__ */ new Set([
   "spring",
+  "express",
   "fastapi",
   "django",
   "flask",
@@ -231643,7 +232721,11 @@ var backendStackIds = /* @__PURE__ */ new Set([
   "java",
   "python",
   "php",
+  "laravel",
   "go",
+  "ruby_rails",
+  "kotlin",
+  "kotlin_spring",
   "node_typescript",
   "node_javascript"
 ]);
@@ -231861,6 +232943,7 @@ function buildDetectionContext(workspaceRoot, filePaths, pathsByFileName, extens
 function toDetectedStack(adapterId) {
   switch (adapterId) {
     case "node_typescript":
+    case "express":
     case "nestjs":
     case "java":
     case "spring":
@@ -231870,7 +232953,11 @@ function toDetectedStack(adapterId) {
     case "dotnet":
     case "python":
     case "php":
+    case "laravel":
     case "go":
+    case "ruby_rails":
+    case "kotlin":
+    case "kotlin_spring":
     case "react":
     case "nextjs":
     case "angular":
@@ -231891,6 +232978,9 @@ function resolveLanguages(stacks) {
   if (stacks.includes("spring")) {
     languages.add("java");
   }
+  if (stacks.includes("kotlin") || stacks.includes("kotlin_spring")) {
+    languages.add("kotlin");
+  }
   if (stacks.includes("dotnet")) {
     languages.add("csharp");
   }
@@ -231909,6 +232999,12 @@ function resolveLanguages(stacks) {
   if (stacks.includes("php")) {
     languages.add("php");
   }
+  if (stacks.includes("laravel")) {
+    languages.add("php");
+  }
+  if (stacks.includes("ruby_rails")) {
+    languages.add("ruby");
+  }
   if (stacks.includes("go")) {
     languages.add("go");
   }
@@ -231922,6 +233018,12 @@ function resolveLanguages(stacks) {
     languages.add("typescript");
     languages.add("javascript");
   }
+  if (stacks.includes("express")) {
+    languages.add("javascript");
+    if (stacks.includes("node_typescript")) {
+      languages.add("typescript");
+    }
+  }
   if (stacks.includes("react") || stacks.includes("nextjs") || stacks.includes("angular") || stacks.includes("vue")) {
     languages.add(stacks.includes("node_typescript") ? "typescript" : "javascript");
   }
@@ -232394,11 +233496,12 @@ var appRouteReservedDirectoryNames = /* @__PURE__ */ new Set([
   "common",
   "shared-ui"
 ]);
-var sourceFileExtensions = /* @__PURE__ */ new Set([
+var sourceFileExtensions3 = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
   ".js",
   ".jsx",
+  ".vue",
   ".java",
   ".py",
   ".php",
@@ -232433,7 +233536,9 @@ var roleFileHints = [
   "layout.tsx",
   "layout.jsx",
   "route.ts",
-  "route.js"
+  "route.js",
+  "view.vue",
+  "page.vue"
 ];
 function normalizePath13(value) {
   return value.replaceAll("\\", "/");
@@ -232509,7 +233614,7 @@ function inspectModuleFolder(absolutePath) {
         continue;
       }
       const extension = path53.extname(entry.name).toLowerCase();
-      if (sourceFileExtensions.has(extension)) {
+      if (sourceFileExtensions3.has(extension)) {
         hasSourceFiles = true;
         sourceFileCount += 1;
       }
@@ -232589,14 +233694,17 @@ function collectModuleCandidatesFromRoot(workspaceRoot, modulesRootRelative, def
     if (skipFrontendUtilities && frontendUtilityDirectoryNames.has(entry.name.toLowerCase())) {
       continue;
     }
-    const moduleName = entry.name;
-    const moduleRelativePath = normalizePath13(`${modulesRootRelative}/${moduleName}`);
+    const rootSegments = modulesRootRelative.split("/").filter((segment) => segment.length > 0);
+    const sourceIndex = rootSegments.lastIndexOf("src");
+    const rootLeaf = rootSegments[rootSegments.length - 1]?.toLowerCase();
+    const parentName = sourceIndex > 0 && (rootLeaf === "src" || ["modules", "features"].includes(rootLeaf ?? "")) ? rootSegments[sourceIndex - 1] : void 0;
+    const moduleName = parentName && parentName !== "src" ? `${parentName}/${entry.name}` : ["domain", "domains", "application", "infrastructure"].includes(rootLeaf ?? "") ? `${rootSegments[rootSegments.length - 1]}/${entry.name}` : entry.name;
     const moduleAbsolutePath = path53.join(absoluteRoot, entry.name);
     const inspected = inspectModuleFolder(moduleAbsolutePath);
     const detected = makeDetectedModule(
       workspaceRoot,
       moduleName,
-      moduleRelativePath,
+      normalizePath13(`${modulesRootRelative}/${entry.name}`),
       modulesRootRelative,
       inspected.hasSourceFiles,
       inspected.hasRoleFiles,
@@ -232657,12 +233765,22 @@ function collectExplicitRoots(workspaceRoot) {
   for (const root of [
     "src/modules",
     "src/features",
+    "src/domain",
+    "src/domains",
+    "src/application",
+    "src/infrastructure",
     "src/app",
     "app",
     "backend/src/modules",
     "backend/src/features",
     "frontend/src/modules",
     "frontend/src/features",
+    "frontend/src/views",
+    "src/views",
+    "routes",
+    "src/routes",
+    "app/Modules",
+    "app/services",
     "services",
     "packages",
     "libs"
@@ -232677,8 +233795,13 @@ function collectExplicitRoots(workspaceRoot) {
       continue;
     }
     for (const candidate of [
+      `apps/${appEntry.name}/src`,
       `apps/${appEntry.name}/src/modules`,
       `apps/${appEntry.name}/src/features`,
+      `apps/${appEntry.name}/src/domain`,
+      `apps/${appEntry.name}/src/domains`,
+      `apps/${appEntry.name}/src/application`,
+      `apps/${appEntry.name}/src/infrastructure`,
       `apps/${appEntry.name}/app`,
       `apps/${appEntry.name}/src/app`
     ]) {
@@ -232687,8 +233810,70 @@ function collectExplicitRoots(workspaceRoot) {
       }
     }
   }
+  for (const container of ["packages", "services"]) {
+    const containerRoot = path53.join(workspaceRoot, container);
+    for (const containerEntry of safeReadDirEntries(containerRoot)) {
+      if (!containerEntry.isDirectory() || ignoredDirectoryNames4.has(containerEntry.name)) {
+        continue;
+      }
+      for (const candidate of [
+        `${container}/${containerEntry.name}/src`,
+        `${container}/${containerEntry.name}/src/modules`,
+        `${container}/${containerEntry.name}/src/features`,
+        `${container}/${containerEntry.name}/src/domain`,
+        `${container}/${containerEntry.name}/src/domains`,
+        `${container}/${containerEntry.name}/src/application`,
+        `${container}/${containerEntry.name}/src/infrastructure`
+      ]) {
+        if (pathExists15(path53.join(workspaceRoot, ...candidate.split("/")))) {
+          roots.push(candidate);
+        }
+      }
+    }
+  }
   return uniqueSorted(roots);
 }
+function collectJavaPackageRoots(workspaceRoot) {
+  const roots = [];
+  for (const sourceRoot of ["src/main/java", "src/main/kotlin", "src"]) {
+    const absoluteSourceRoot = path53.join(workspaceRoot, ...sourceRoot.split("/"));
+    if (!pathExists15(absoluteSourceRoot)) {
+      continue;
+    }
+    const queue = [
+      { absolutePath: absoluteSourceRoot, relativePath: sourceRoot, depth: 0 }
+    ];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current) {
+        continue;
+      }
+      if (current.depth > 6) {
+        continue;
+      }
+      for (const entry of safeReadDirEntries(current.absolutePath)) {
+        if (!entry.isDirectory() || ignoredDirectoryNames4.has(entry.name)) {
+          continue;
+        }
+        const childRelativePath = normalizePath13(`${current.relativePath}/${entry.name}`);
+        const lowerName = entry.name.toLowerCase();
+        if (lowerName === "modules" || lowerName === "features") {
+          const childCount = safeReadDirEntries(path53.join(current.absolutePath, entry.name)).filter((child) => child.isDirectory() && !ignoredDirectoryNames4.has(child.name)).length;
+          if (childCount >= 2) {
+            roots.push(childRelativePath);
+          }
+          continue;
+        }
+        queue.push({
+          absolutePath: path53.join(current.absolutePath, entry.name),
+          relativePath: childRelativePath,
+          depth: current.depth + 1
+        });
+      }
+    }
+  }
+  return roots;
+}
 function collectFallbackSrcModules(workspaceRoot, context) {
   const srcRoot = path53.join(workspaceRoot, "src");
   const srcEntries = safeReadDirEntries(srcRoot).filter((entry) => entry.isDirectory() && !ignoredDirectoryNames4.has(entry.name)).sort((left, right) => left.name.localeCompare(right.name));
@@ -232726,6 +233911,14 @@ function detectModules(workspaceRoot, options) {
     projectKinds: options?.projectKinds,
     stacks: options?.stacks
   };
+  if (options?.stacks?.some((stack) => stack === "java" || stack === "spring" || stack === "kotlin" || stack === "kotlin_spring")) {
+    for (const root of collectJavaPackageRoots(workspaceRoot)) {
+      if (!explicitRoots.includes(root)) {
+        explicitRoots.push(root);
+      }
+    }
+    explicitRoots.sort((left, right) => left.localeCompare(right));
+  }
   for (const root of explicitRoots) {
     if (root.endsWith("/src/modules") || root === "src/modules" || root === "backend/src/modules") {
       evidence.push(`Found ${root} directory`);
@@ -233732,6 +234925,8 @@ function resolveImplementationProfile(input2) {
       return "frontend-vue";
     case "nestjs":
       return input2.apiStyleHint === "rest" ? "backend-nestjs-rest" : "backend-nestjs";
+    case "express":
+      return input2.apiStyleHint === "rest" ? "backend-express-rest" : "backend-express";
     case "spring":
       return input2.apiStyleHint === "rest" ? "backend-spring-rest" : "backend-spring";
     case "fastapi":
@@ -233748,6 +234943,14 @@ function resolveImplementationProfile(input2) {
       return "backend-python";
     case "php":
       return "backend-php";
+    case "laravel":
+      return input2.apiStyleHint === "rest" ? "backend-laravel-rest" : "backend-laravel";
+    case "ruby_rails":
+      return input2.apiStyleHint === "rest" ? "backend-rails-rest" : "backend-rails";
+    case "kotlin":
+      return "backend-kotlin";
+    case "kotlin_spring":
+      return input2.apiStyleHint === "rest" ? "backend-kotlin-spring-rest" : "backend-kotlin-spring";
     case "go":
       return "backend-go";
     case "node_typescript":
@@ -233910,7 +235113,7 @@ function resolveStackSelections(detection, projectKinds) {
   }
   if (projectKinds.includes("library")) {
     const selectedLibrary = detection.stacks.selectedAdapterId;
-    if (selectedLibrary === "terraform" || selectedLibrary === "ansible" || selectedLibrary === "node_typescript" || selectedLibrary === "python" || selectedLibrary === "go") {
+    if (selectedLibrary === "terraform" || selectedLibrary === "ansible" || selectedLibrary === "node_typescript" || selectedLibrary === "python" || selectedLibrary === "go" || selectedLibrary === "kotlin") {
       selections.library = selectedLibrary;
     }
   }