@archpilotlabs/archpilot 0.0.7 → 0.0.9

package/README.md

@@ -5,14 +5,18 @@
 <h1 align="center">ArchPilot</h1>
 
 <p align="center">
-  Continuous architecture governance for engineering teams
+  Architecture guardrails for AI-native software development
 </p>
 
+ArchPilot validates your repository against architecture rules and helps engineering teams move faster with AI-assisted development-without sacrificing architectural integrity.
+
+**Your AI writes code. ArchPilot protects architecture.**
+
 <p align="center">
   Validate • Enforce • Measure architecture continuously
 </p>
 
-ArchPilot is a CLI that validates your repository against architecture rules and helps you keep your system **visible, enforceable, and measurable** as it evolves.
+ArchPilot makes architecture **visible, enforceable, and measurable** as your system evolves.
 
 ---
 
@@ -24,6 +28,10 @@ Over time, boundaries blur, dependencies leak, and architectural decisions drift
 
 ArchPilot turns architecture into something you can **actually validate, enforce, and track continuously**.
 
+AI accelerates code delivery-but architectural drift accelerates too.
+
+ArchPilot gives teams deterministic architecture guardrails in local development, CI, and governance workflows.
+
 ---
 
 ## 🚀 What it does
@@ -40,7 +48,46 @@ No runtime agents. No external services. Fully deterministic and local-first.
 
 ---
 
-## Local-first. Cloud-powered.
+## 🧩 Supported Stacks
+
+ArchPilot supports **practical deterministic architecture detection** across modern application stacks.
+
+### Backend
+
+* Node.js / TypeScript
+* NestJS
+* Express.js
+* Java
+* Spring / Spring Boot
+* Kotlin
+* FastAPI
+* Django
+* Flask
+* PHP
+* Laravel
+* Go
+* .NET
+* Ruby on Rails
+
+### Frontend
+
+* React
+* Next.js
+* Angular
+* Vue
+
+### Infrastructure
+
+* Terraform
+* Ansible
+
+ArchPilot detects stack shape from practical repository evidence - framework markers, manifests, project layout, and source structure - then applies conservative architecture discovery defaults locally.
+
+**No cloud scanning. No remote indexing. Deterministic local validation.**
+
+---
+
+## ☁️ Local-first. Cloud-powered.
 
 Start locally in minutes:
 
@@ -65,12 +112,9 @@ archpilot cloud connect
 archpilot cloud disconnect
 ```
 
-Cloud setup only asks for your API token. ArchPilot uses the canonical production API automatically:
-
-`https://api.archpilot.org`
-
-For local development, set `ARCHPILOT_CLOUD_URL=http://localhost:4000` before running Cloud commands. CLI `--server` remains available for one-off debugging and automated tests.
+Cloud setup only asks for your API token.
 
+ArchPilot uses the canonical production API automatically-no server URL setup required for normal use.
 Learn more:
 
 https://archpilot.org/docs
@@ -203,7 +247,7 @@ archpilot governance upload
 
 ---
 
-## 🧩 Core Capabilities
+## ⚙️ Core Capabilities
 
 * Architecture-as-code (`.archpilot/`)
 * Dependency validation and module contracts

package/dist/archpilot-cli.js

@@ -210932,15 +210932,20 @@ 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",
   "fastapi",
+  "django",
+  "flask",
   "python",
   "php",
+  "laravel",
   "go",
   "dotnet",
   "ruby_rails",
+  "kotlin",
   "kotlin_spring",
   "rust",
   "react",
@@ -210954,15 +210959,20 @@ var validCanonicalStackIds = /* @__PURE__ */ new Set([
 ]);
 var canonicalStackLabels = {
   node_typescript: "TypeScript / Node.js",
+  express: "Express.js",
   nestjs: "NestJS",
   java: "Java",
   spring: "Spring",
   fastapi: "FastAPI",
+  django: "Django",
+  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",
@@ -211173,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,
@@ -211448,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",
@@ -211470,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"
     },
@@ -211496,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,
@@ -211520,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;
@@ -211538,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;
@@ -211583,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;
       }
@@ -211805,6 +211912,326 @@ var stackAdaptersById = {
     resolveProjectKinds: () => ["backend"],
     getImportExtractionMode: () => "python-imports"
   }),
+  django: buildAdapter({
+    id: "django",
+    displayName: canonicalStackLabels.django,
+    ecosystem: "python",
+    category: "framework",
+    priority: 68,
+    manifestDetectionHints: [
+      "requirements.txt",
+      "pyproject.toml",
+      "Pipfile",
+      "Pipfile.lock",
+      "poetry.lock",
+      "manage.py",
+      "settings.py",
+      "urls.py",
+      "wsgi.py",
+      "asgi.py"
+    ],
+    buildToolHints: ["pip", "poetry", "django-admin"],
+    defaults: {
+      sourceRoots: [".", "src", "app"],
+      moduleRootCandidates: [".", "src", "app"],
+      apiRoots: [".", "src", "app"],
+      databaseRoots: ["migrations", "db", "database"],
+      configFiles: ["requirements.txt", "pyproject.toml", "Pipfile", "Pipfile.lock", "poetry.lock", "manage.py"],
+      fileExtensions: [".py", ".toml", ".txt", ".sql", ".yaml", ".yml"],
+      dependencyFileExtensions: [".py"],
+      ignoreDirectories: [
+        "__pycache__",
+        ".pytest_cache",
+        ".venv",
+        "venv",
+        "dist",
+        "build",
+        ".idea",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["manage.py", "wsgi.py", "asgi.py", "settings.py", "urls.py"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "__init__.py"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let weakSignals = 0;
+      let score = 0;
+      const hasRequirementsDjango = context.hasFileMatchingPattern(
+        "requirements.txt",
+        /(^|\s)django([=<>~!]|$)/imu
+      );
+      const hasPyprojectDjango = context.hasFileMatchingPattern("pyproject.toml", /\bdjango\b/iu);
+      const hasPoetryLockDjango = context.hasFileMatchingPattern(
+        "poetry.lock",
+        /\bname\s*=\s*["']django["']/iu
+      );
+      const hasPipfileDjango = context.hasFileMatchingPattern("Pipfile", /\bdjango\b/iu);
+      const hasPipfileLockDjango = context.hasFileMatchingPattern("Pipfile.lock", /"django"\s*:/iu);
+      const hasDjangoDependencyEvidence = hasRequirementsDjango || hasPyprojectDjango || hasPoetryLockDjango || hasPipfileDjango || hasPipfileLockDjango;
+      const hasManagePy = context.hasFile("manage.py");
+      const hasDjangoSettingsModule = context.hasFileMatchingPattern(
+        "manage.py",
+        /\bDJANGO_SETTINGS_MODULE\b/u
+      );
+      const hasSettingsPy = context.hasFile("settings.py");
+      const hasUrlsPy = context.hasFile("urls.py");
+      const hasWsgiOrAsgi = context.hasFile("wsgi.py") || context.hasFile("asgi.py");
+      const hasInstalledApps = context.hasFileMatchingPattern("settings.py", /\bINSTALLED_APPS\s*=/u);
+      const hasDjangoAdmin = context.hasAnyFileMatchingPattern(/(^|\/)(manage|settings|urls|wsgi|asgi)\.py$/iu, /\bdjango-admin\b/iu);
+      const hasDjangoImport = context.hasAnyFileMatchingPattern(/\.py$/iu, /\b(from|import)\s+django\b/u);
+      const hasDjangoUrlsImport = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\bfrom\s+django\.urls\s+import\s+(?:path|include|re_path)\b/u
+      );
+      if (hasRequirementsDjango) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found requirements.txt with django dependency");
+      }
+      if (hasPyprojectDjango) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found pyproject.toml with django dependency");
+      }
+      if (hasPoetryLockDjango || hasPipfileDjango || hasPipfileLockDjango) {
+        strongSignals += 1;
+        score += 50;
+        evidence.push("Found Pipfile/lock metadata with django dependency");
+      }
+      if (hasManagePy) {
+        strongSignals += 1;
+        score += 34;
+        evidence.push("Found manage.py");
+      }
+      if (hasDjangoSettingsModule) {
+        strongSignals += 1;
+        score += 24;
+        evidence.push("Found DJANGO_SETTINGS_MODULE in manage.py");
+      }
+      if (hasInstalledApps) {
+        strongSignals += 1;
+        score += 24;
+        evidence.push("Found INSTALLED_APPS in settings.py");
+      }
+      if (hasDjangoImport) {
+        strongSignals += 1;
+        score += 22;
+        evidence.push("Found django import in source");
+      }
+      if (hasSettingsPy) {
+        mediumSignals += 1;
+        score += 12;
+        evidence.push("Found settings.py");
+      }
+      if (hasUrlsPy) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found urls.py");
+      }
+      if (hasWsgiOrAsgi) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found wsgi.py or asgi.py");
+      }
+      if (hasDjangoUrlsImport) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found Django URL routing import");
+      }
+      if (hasDjangoAdmin) {
+        weakSignals += 1;
+        score += 3;
+        evidence.push("Found django-admin reference");
+      }
+      if (context.hasDirectory("migrations")) {
+        weakSignals += 1;
+        score += 2;
+        evidence.push("Found migrations directory");
+      }
+      const hasSafeDjangoCoreEvidence = hasDjangoDependencyEvidence || hasManagePy && (hasDjangoSettingsModule || hasSettingsPy || hasUrlsPy || hasWsgiOrAsgi) || hasInstalledApps && (hasSettingsPy || hasDjangoImport) || hasDjangoImport && (hasDjangoUrlsImport || hasUrlsPy);
+      if (!hasSafeDjangoCoreEvidence || strongSignals === 0) {
+        return null;
+      }
+      const hasRestEvidence = hasUrlsPy || hasDjangoUrlsImport;
+      const confidence = strongSignals >= 2 ? "high" : strongSignals >= 1 || mediumSignals >= 3 || mediumSignals >= 2 && weakSignals >= 1 ? "medium" : "low";
+      return toResult({
+        adapterId: "django",
+        confidence,
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRestEvidence ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "python-imports"
+  }),
+  flask: buildAdapter({
+    id: "flask",
+    displayName: canonicalStackLabels.flask,
+    ecosystem: "python",
+    category: "framework",
+    priority: 66,
+    manifestDetectionHints: [
+      "requirements.txt",
+      "pyproject.toml",
+      "Pipfile",
+      "Pipfile.lock",
+      "poetry.lock",
+      "app.py",
+      "wsgi.py",
+      "main.py"
+    ],
+    buildToolHints: ["pip", "poetry", "flask"],
+    defaults: {
+      sourceRoots: ["app", "src", "."],
+      moduleRootCandidates: ["app", "src/app", "src", "blueprints", "api"],
+      apiRoots: ["app", "src", "blueprints", "api"],
+      databaseRoots: ["migrations", "app/db", "app/database", "src/db", "src/database"],
+      configFiles: ["requirements.txt", "pyproject.toml", "Pipfile", "Pipfile.lock", "poetry.lock"],
+      fileExtensions: [".py", ".toml", ".txt", ".sql", ".yaml", ".yml"],
+      dependencyFileExtensions: [".py"],
+      ignoreDirectories: [
+        "__pycache__",
+        ".pytest_cache",
+        ".venv",
+        "venv",
+        "dist",
+        "build",
+        ".idea",
+        ...commonIgnoreDirectories
+      ],
+      entrypointHints: ["app.py", "main.py", "wsgi.py", "app/__init__.py"],
+      publicEntrypointDirectories: [],
+      moduleIndexFileName: "__init__.py"
+    },
+    detect: (context) => {
+      const evidence = [];
+      let strongSignals = 0;
+      let mediumSignals = 0;
+      let weakSignals = 0;
+      let score = 0;
+      const hasRequirementsFlask = context.hasFileMatchingPattern(
+        "requirements.txt",
+        /(^|\s)flask([=<>~!]|$)/imu
+      );
+      const hasPyprojectFlask = context.hasFileMatchingPattern("pyproject.toml", /\bflask\b/iu);
+      const hasPoetryLockFlask = context.hasFileMatchingPattern(
+        "poetry.lock",
+        /\bname\s*=\s*["']flask["']/iu
+      );
+      const hasPipfileFlask = context.hasFileMatchingPattern("Pipfile", /\bflask\b/iu);
+      const hasPipfileLockFlask = context.hasFileMatchingPattern("Pipfile.lock", /"flask"\s*:/iu);
+      const hasFlaskDependencyEvidence = hasRequirementsFlask || hasPyprojectFlask || hasPoetryLockFlask || hasPipfileFlask || hasPipfileLockFlask;
+      const hasFlaskImport = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\bfrom\s+flask\s+import\s+.*\bFlask\b/u
+      );
+      const hasFlaskConstruction = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\b\w+\s*=\s*Flask\s*\(\s*__name__/u
+      );
+      const hasRouteDecorator = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /@\w+\.route\s*\(/u
+      );
+      const hasMethodRouteDecorator = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /@\w+\.(?:get|post|put|delete)\s*\(/u
+      );
+      const hasBlueprintImport = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\bfrom\s+flask\s+import\s+.*\bBlueprint\b/u
+      );
+      const hasBlueprintConstruction = context.hasAnyFileMatchingPattern(
+        /\.py$/iu,
+        /\b\w+\s*=\s*Blueprint\s*\(/u
+      );
+      const hasFlaskEntrypointConstruction = context.hasAnyFileMatchingPattern(
+        /(^|\/)(app|main|wsgi)\.py$/iu,
+        /\b\w+\s*=\s*Flask\s*\(/u
+      );
+      if (hasRequirementsFlask) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found requirements.txt with flask dependency");
+      }
+      if (hasPyprojectFlask) {
+        strongSignals += 1;
+        score += 52;
+        evidence.push("Found pyproject.toml with flask dependency");
+      }
+      if (hasPoetryLockFlask || hasPipfileFlask || hasPipfileLockFlask) {
+        strongSignals += 1;
+        score += 50;
+        evidence.push("Found Pipfile/lock metadata with flask dependency");
+      }
+      if (hasFlaskImport) {
+        strongSignals += 1;
+        score += 34;
+        evidence.push("Found Flask import in source");
+      }
+      if (hasFlaskConstruction) {
+        strongSignals += 1;
+        score += 34;
+        evidence.push("Found Flask application construction in source");
+      }
+      if (hasRouteDecorator) {
+        strongSignals += 1;
+        score += 22;
+        evidence.push("Found Flask route decorator in source");
+      }
+      if (hasMethodRouteDecorator) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found Flask method route decorator in source");
+      }
+      if (hasBlueprintImport) {
+        mediumSignals += 1;
+        score += 10;
+        evidence.push("Found Blueprint import in source");
+      }
+      if (hasBlueprintConstruction) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Blueprint construction in source");
+      }
+      if (hasFlaskEntrypointConstruction) {
+        mediumSignals += 1;
+        score += 8;
+        evidence.push("Found Flask construction in app.py/main.py/wsgi.py");
+      }
+      if (context.hasDirectory("blueprints")) {
+        weakSignals += 1;
+        score += 2;
+        evidence.push("Found blueprints directory");
+      }
+      if (context.hasDirectory("app") || context.hasDirectory("src")) {
+        weakSignals += 1;
+        score += 2;
+        evidence.push("Found typical Python backend layout directory");
+      }
+      const hasSafeFlaskCoreEvidence = hasFlaskDependencyEvidence || hasFlaskImport && hasFlaskConstruction || hasFlaskImport && (hasRouteDecorator || hasMethodRouteDecorator || hasBlueprintImport) || hasBlueprintImport && hasBlueprintConstruction;
+      if (!hasSafeFlaskCoreEvidence || strongSignals === 0) {
+        return null;
+      }
+      const hasRestEvidence = hasRouteDecorator || hasMethodRouteDecorator || hasBlueprintImport;
+      const confidence = strongSignals >= 2 ? "high" : strongSignals >= 1 || mediumSignals >= 3 || mediumSignals >= 2 && weakSignals >= 1 ? "medium" : "low";
+      return toResult({
+        adapterId: "flask",
+        confidence,
+        score,
+        evidence,
+        projectKindHints: ["backend"],
+        apiStyleHint: hasRestEvidence ? "rest" : "unknown"
+      });
+    },
+    resolveProjectKinds: () => ["backend"],
+    getImportExtractionMode: () => "python-imports"
+  }),
   python: buildAdapter({
     id: "python",
     displayName: canonicalStackLabels.python,
@@ -211867,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,
@@ -212154,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({
@@ -212426,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) {
@@ -212441,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) {
@@ -212461,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) {
@@ -231311,13 +231992,20 @@ var ignoredDirectoryNames2 = /* @__PURE__ */ new Set([
 ]);
 var backendStackIds = /* @__PURE__ */ new Set([
   "spring",
+  "express",
   "fastapi",
+  "django",
+  "flask",
   "dotnet",
   "nestjs",
   "java",
   "python",
   "php",
+  "laravel",
   "go",
+  "ruby_rails",
+  "kotlin",
+  "kotlin_spring",
   "node_typescript",
   "node_javascript"
 ]);
@@ -231535,14 +232223,21 @@ function buildDetectionContext(workspaceRoot, filePaths, pathsByFileName, extens
 function toDetectedStack(adapterId) {
   switch (adapterId) {
     case "node_typescript":
+    case "express":
     case "nestjs":
     case "java":
     case "spring":
     case "fastapi":
+    case "django":
+    case "flask":
     case "dotnet":
     case "python":
     case "php":
+    case "laravel":
     case "go":
+    case "ruby_rails":
+    case "kotlin":
+    case "kotlin_spring":
     case "react":
     case "nextjs":
     case "angular":
@@ -231563,6 +232258,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");
   }
@@ -231572,9 +232270,21 @@ function resolveLanguages(stacks) {
   if (stacks.includes("fastapi")) {
     languages.add("python");
   }
+  if (stacks.includes("django")) {
+    languages.add("python");
+  }
+  if (stacks.includes("flask")) {
+    languages.add("python");
+  }
   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");
   }
@@ -231588,6 +232298,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");
   }
@@ -232065,6 +232781,7 @@ var sourceFileExtensions = /* @__PURE__ */ new Set([
   ".tsx",
   ".js",
   ".jsx",
+  ".vue",
   ".java",
   ".py",
   ".php",
@@ -232099,7 +232816,9 @@ var roleFileHints = [
   "layout.tsx",
   "layout.jsx",
   "route.ts",
-  "route.js"
+  "route.js",
+  "view.vue",
+  "page.vue"
 ];
 function normalizePath13(value) {
   return value.replaceAll("\\", "/");
@@ -232329,6 +233048,12 @@ function collectExplicitRoots(workspaceRoot) {
     "backend/src/features",
     "frontend/src/modules",
     "frontend/src/features",
+    "frontend/src/views",
+    "src/views",
+    "routes",
+    "src/routes",
+    "app/Modules",
+    "app/services",
     "services",
     "packages",
     "libs"
@@ -232355,6 +233080,47 @@ function collectExplicitRoots(workspaceRoot) {
   }
   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));
@@ -232392,6 +233158,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`);
@@ -233398,10 +234172,16 @@ 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":
       return input2.apiStyleHint === "rest" ? "backend-fastapi-rest" : "backend-fastapi";
+    case "django":
+      return input2.apiStyleHint === "rest" ? "backend-django-rest" : "backend-django";
+    case "flask":
+      return input2.apiStyleHint === "rest" ? "backend-flask-rest" : "backend-flask";
     case "dotnet":
       return input2.apiStyleHint === "rest" ? "backend-dotnet-webapi" : "backend-dotnet";
     case "java":
@@ -233410,6 +234190,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":
@@ -233457,6 +234245,9 @@ function resolveNormalizedProjectKinds(detection, evidence) {
     addEvidence6(evidence, `Normalized project kinds from selected adapter '${selectedAdapter.id}' hints`);
   } else if (detection.topology.topology === "monorepo" && selectedHints.length > 0) {
     normalizedKinds = uniqueSortedKinds([...heuristicKinds, ...selectedHints]);
+    if (normalizedKinds.includes("library") && !selectedHints.includes("library") && (detection.architectureStyleSignals?.sharedPackageCount ?? 0) === 0) {
+      normalizedKinds = normalizedKinds.filter((kind) => kind !== "library");
+    }
     addEvidence6(evidence, "Normalized monorepo project kinds from adapter hints plus heuristic evidence");
   } else if (heuristicKinds.length > 0) {
     normalizedKinds = uniqueSortedKinds(heuristicKinds);
@@ -233569,7 +234360,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;
     }
   }

package/package.json

@@ -1,34 +1,34 @@
-{
-  "name": "@archpilotlabs/archpilot",
-  "version": "0.0.7",
-  "description": "Executable architecture governance CLI",
-  "homepage": "https://archpilot.org",
-  "bugs": {
-    "url": "https://archpilot.org/contact"
-  },
-  "license": "SEE LICENSE IN LICENSE",
-  "bin": {
-    "archpilot": "./dist/archpilot-cli.js"
-  },
-  "main": "./dist/archpilot-cli.js",
-  "files": [
-    "dist"
-  ],
-  "keywords": [
-    "architecture",
-    "architecture-validation",
-    "governance",
-    "cli",
-    "dependency-validation",
-    "adr",
-    "ci",
-    "developer-tools"
-  ],
-  "scripts": {
-    "build": "npm run compile",
-    "compile": "npm run check-types && npm run lint && node esbuild.js",
-    "watch": "node esbuild.js --watch",
-    "check-types": "tsc --noEmit -p tsconfig.json",
-    "lint": "eslint src"
-  }
-}
+{
+  "name": "@archpilotlabs/archpilot",
+  "version": "0.0.9",
+  "description": "Executable architecture governance CLI",
+  "homepage": "https://archpilot.org",
+  "bugs": {
+    "url": "https://archpilot.org/contact"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "bin": {
+    "archpilot": "./dist/archpilot-cli.js"
+  },
+  "main": "./dist/archpilot-cli.js",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "architecture",
+    "architecture-validation",
+    "governance",
+    "cli",
+    "dependency-validation",
+    "adr",
+    "ci",
+    "developer-tools"
+  ],
+  "scripts": {
+    "build": "npm run compile",
+    "compile": "npm run check-types && npm run lint && node esbuild.js",
+    "watch": "node esbuild.js --watch",
+    "check-types": "tsc --noEmit -p tsconfig.json",
+    "lint": "eslint src"
+  }
+}