claudeos-core 1.0.7 → 1.2.0

package/plan-installer/index.js

@@ -3,17 +3,17 @@
 /**
  * ClaudeOS-Core — plan-installer
  *
- * 역할: 프로젝트 분석 → 스택 감지 → 도메인 목록 → 그룹 자동 분할 → 프롬프트 동적 생성
- * 출력:
- *   - claudeos-core/generated/project-analysis.json  (스택/구조 정보, 멀티스택 포함)
- *   - claudeos-core/generated/domain-groups.json     (Pass 1 실행용 그룹 분할, 타입별)
- *   - claudeos-core/generated/pass1-backend-prompt.md (백엔드 분석 프롬프트)
- *   - claudeos-core/generated/pass1-frontend-prompt.md (프론트엔드 분석 프롬프트, 감지 시)
- *   - claudeos-core/generated/pass1-prompt.md        (단일스택 하위 호환)
+ * Role: Project analysis → Stack detection → Domain list → Auto group splitting → Dynamic prompt generation
+ * Output:
+ *   - claudeos-core/generated/project-analysis.json  (stack/structure info, multi-stack aware)
+ *   - claudeos-core/generated/domain-groups.json     (group splitting for Pass 1 execution, per type)
+ *   - claudeos-core/generated/pass1-backend-prompt.md (backend analysis prompt)
+ *   - claudeos-core/generated/pass1-frontend-prompt.md (frontend analysis prompt, if detected)
+ *   - claudeos-core/generated/pass1-prompt.md        (single-stack backward compat)
  *   - claudeos-core/generated/pass2-prompt.md
- *   - claudeos-core/generated/pass3-prompt.md        (멀티스택 시 결합 프롬프트)
+ *   - claudeos-core/generated/pass3-prompt.md        (combined prompt for multi-stack)
  *
- * 실행: npx claudeos-core <cmd> 또는 node claudeos-core-tools/plan-installer/index.js
+ * Usage: npx claudeos-core <cmd> or node claudeos-core-tools/plan-installer/index.js
  */
 
 const fs = require("fs");
@@ -28,7 +28,7 @@ function ensureDir(dir) {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 }
 
-// ─── 스택 감지 (멀티스택) ────────────────────────────────
+// ─── Stack detection (multi-stack) ────────────────────────────────
 async function detectStack() {
   const stack = {
     language: null, languageVersion: null,
@@ -38,20 +38,137 @@ async function detectStack() {
     packageManager: null, detected: [],
   };
 
-  // ── Java: Gradle ──
-  if (fs.existsSync(path.join(ROOT, "build.gradle"))) {
-    const g = fs.readFileSync(path.join(ROOT, "build.gradle"), "utf-8");
-    stack.buildTool = "gradle"; stack.detected.push("build.gradle");
+  // ── Java/Kotlin: Gradle ──
+  const gradleFile = fs.existsSync(path.join(ROOT, "build.gradle.kts"))
+    ? "build.gradle.kts"
+    : fs.existsSync(path.join(ROOT, "build.gradle")) ? "build.gradle" : null;
+  if (gradleFile) {
+    const g = fs.readFileSync(path.join(ROOT, gradleFile), "utf-8");
+    stack.buildTool = "gradle"; stack.detected.push(gradleFile);
     if (g.includes("spring-boot")) { stack.language = "java"; stack.framework = "spring-boot"; stack.detected.push("spring-boot"); }
-    const sv = g.match(/org\.springframework\.boot.*version\s*['"]([^'"]+)['"]/);
-    if (sv) stack.frameworkVersion = sv[1];
+    const svPatterns = [
+      /org\.springframework\.boot.*version\s*['"]([^'"]+)['"]/,
+      /id\s*\(\s*["']org\.springframework\.boot["']\s*\)\s*version\s*["']([^"']+)["']/,
+      /spring-boot-dependencies:([^'")\s]+)/,
+    ];
+    for (const pattern of svPatterns) {
+      const sv = g.match(pattern);
+      if (sv) { stack.frameworkVersion = sv[1]; break; }
+    }
     const jv = g.match(/sourceCompatibility\s*=\s*['"]?(\d+)['"]?/);
     if (jv) stack.languageVersion = jv[1];
-    if (g.includes("mybatis")) { stack.orm = "mybatis"; stack.detected.push("mybatis"); }
-    if (g.includes("jpa") || g.includes("hibernate")) { stack.orm = "jpa"; stack.detected.push("jpa"); }
-    if (g.includes("postgresql")) { stack.database = "postgresql"; stack.detected.push("postgresql"); }
-    if (g.includes("mysql")) { stack.database = "mysql"; stack.detected.push("mysql"); }
-    if (g.includes("oracle")) { stack.database = "oracle"; stack.detected.push("oracle"); }
+    // ORM detection (first match wins — order by specificity)
+    if (!stack.orm && g.includes("mybatis")) { stack.orm = "mybatis"; stack.detected.push("mybatis"); }
+    if (!stack.orm && (g.includes("jpa") || g.includes("hibernate"))) { stack.orm = "jpa"; stack.detected.push("jpa"); }
+    if (!stack.orm && g.includes("exposed")) { stack.orm = "exposed"; stack.detected.push("exposed"); }
+    if (!stack.orm && g.includes("jooq")) { stack.orm = "jooq"; stack.detected.push("jooq"); }
+    if (!stack.orm && g.includes("spring-data-jdbc")) { stack.orm = "spring-data-jdbc"; stack.detected.push("spring-data-jdbc"); }
+    if (!stack.orm && g.includes("r2dbc")) { stack.orm = "r2dbc"; stack.detected.push("r2dbc"); }
+    // DB detection
+    if (!stack.database && g.includes("postgresql")) { stack.database = "postgresql"; stack.detected.push("postgresql"); }
+    if (!stack.database && g.includes("mysql")) { stack.database = "mysql"; stack.detected.push("mysql"); }
+    if (!stack.database && g.includes("oracle")) { stack.database = "oracle"; stack.detected.push("oracle"); }
+    if (!stack.database && g.includes("mongodb")) { stack.database = "mongodb"; stack.detected.push("mongodb"); }
+    if (!stack.database && g.includes("h2")) { stack.database = "h2"; stack.detected.push("h2"); }
+    // Kotlin detection: override language if Kotlin plugin found
+    if (g.includes("kotlin") || g.includes("org.jetbrains.kotlin")) {
+      stack.language = "kotlin"; stack.detected.push("kotlin");
+      // Try multiple patterns for Kotlin version extraction
+      const kvPatterns = [
+        /kotlin\S*\s*version\s*['"]([^'"]+)['"]/,
+        /org\.jetbrains\.kotlin\S*\s*version\s*['"]([^'"]+)['"]/,
+        /kotlin\("jvm"\)\s*version\s*["']([^"']+)["']/,
+      ];
+      for (const pattern of kvPatterns) {
+        const match = g.match(pattern);
+        if (match) { stack.languageVersion = match[1]; break; }
+      }
+    }
+  }
+
+  // ── Gradle: version catalogs (libs.versions.toml) — fallback for versions & deps ──
+  const versionCatalog = path.join(ROOT, "gradle/libs.versions.toml");
+  if (fs.existsSync(versionCatalog)) {
+    const vc = fs.readFileSync(versionCatalog, "utf-8");
+    stack.detected.push("libs.versions.toml");
+    // Language version fallback
+    if (!stack.languageVersion) {
+      const kvMatch = vc.match(/kotlin\s*=\s*["']([^"']+)["']/);
+      if (kvMatch) stack.languageVersion = kvMatch[1];
+    }
+    if (!stack.frameworkVersion) {
+      const sbMatch = vc.match(/spring-boot\s*=\s*["']([^"']+)["']/);
+      if (sbMatch) stack.frameworkVersion = sbMatch[1];
+    }
+    // ORM/DB detection from version catalog libraries
+    if (!stack.orm && vc.includes("exposed")) { stack.orm = "exposed"; stack.detected.push("exposed (catalog)"); }
+    if (!stack.orm && vc.includes("jooq")) { stack.orm = "jooq"; stack.detected.push("jooq (catalog)"); }
+    if (!stack.orm && (vc.includes("jpa") || vc.includes("hibernate"))) { stack.orm = "jpa"; stack.detected.push("jpa (catalog)"); }
+    if (!stack.database && vc.includes("postgresql")) { stack.database = "postgresql"; }
+    if (!stack.database && vc.includes("mysql")) { stack.database = "mysql"; }
+    if (!stack.database && vc.includes("mongodb")) { stack.database = "mongodb"; }
+    // Kotlin detection from catalog
+    if (!stack.language && vc.includes("kotlin")) {
+      stack.language = "kotlin"; stack.detected.push("kotlin (catalog)");
+    }
+  }
+
+  // ── Kotlin: multi-module Gradle detection (check subproject build files) ──
+  if (stack.language !== "kotlin" && stack.buildTool === "gradle") {
+    const subBuildFiles = await glob("**/build.gradle{,.kts}", { cwd: ROOT, ignore: ["**/node_modules/**", "**/build/**"] });
+    for (const sbf of subBuildFiles.slice(0, 5)) {
+      const sc = fs.readFileSync(path.join(ROOT, sbf), "utf-8");
+      if (sc.includes("kotlin") || sc.includes("org.jetbrains.kotlin")) {
+        stack.language = "kotlin"; stack.detected.push("kotlin (submodule)");
+        const kv = sc.match(/kotlin\S*\s*version\s*['"]([^'"]+)['"]/);
+        if (kv) stack.languageVersion = kv[1];
+        break;
+      }
+    }
+  }
+
+  // ── Kotlin: detect CQRS/multi-module architecture from settings.gradle ──
+  const settingsFile = fs.existsSync(path.join(ROOT, "settings.gradle.kts"))
+    ? "settings.gradle.kts"
+    : fs.existsSync(path.join(ROOT, "settings.gradle")) ? "settings.gradle" : null;
+  if (settingsFile && stack.language === "kotlin") {
+    const sg = fs.readFileSync(path.join(ROOT, settingsFile), "utf-8");
+
+    // Extract all module names from include() calls
+    // Handles: include(":m1", ":m2"), include(":m1"), include ":m1", ":m2"
+    // Also strips leading ":" prefix (Gradle subproject path convention)
+    // Pre-filter: remove single-line comments to avoid matching commented-out includes
+    const sgClean = sg.split("\n").filter(l => !l.trimStart().startsWith("//")).join("\n");
+    const includes = [];
+    // Kotlin DSL: include(":m1", ":m2", ":m3") — may span multiple lines
+    const includeBlocks = [...sgClean.matchAll(/include\s*\(([^)]*)\)/gs)];
+    for (const block of includeBlocks) {
+      const quotedValues = [...block[1].matchAll(/["']([^"']+)["']/g)].map(m => m[1]);
+      includes.push(...quotedValues);
+    }
+    // Groovy DSL: include ':m1', ':m2', ':m3' — single line, comma-separated
+    if (includes.length === 0) {
+      const groovyIncludes = [...sgClean.matchAll(/include\s+(.+)/g)];
+      for (const line of groovyIncludes) {
+        const quotedValues = [...line[1].matchAll(/['"]([^'"]+)['"]/g)].map(m => m[1]);
+        includes.push(...quotedValues);
+      }
+    }
+
+    // Strip leading ":" prefix from all module names (Gradle convention)
+    const cleanModules = includes.map(m => m.replace(/^:/, ""));
+
+    if (cleanModules.length > 0) {
+      stack.multiModule = true;
+      stack.modules = cleanModules;
+      stack.detected.push(`multi-module (${cleanModules.length} modules)`);
+      // Detect CQRS from module names
+      const hasCommand = cleanModules.some(m => m.includes("command"));
+      const hasQuery = cleanModules.some(m => m.includes("query"));
+      const hasBff = cleanModules.some(m => m.includes("bff"));
+      if (hasCommand && hasQuery) { stack.architecture = "cqrs"; stack.detected.push("cqrs"); }
+      if (hasBff) { stack.detected.push("bff"); }
+    }
   }
 
   // ── Java: Maven ──
@@ -63,28 +180,36 @@ async function detectStack() {
     const jv = pom.match(/<java\.version>(\d+)/);
     if (jv) stack.languageVersion = jv[1];
     if (pom.includes("spring-boot") && !stack.framework) { stack.framework = "spring-boot"; stack.detected.push("spring-boot"); }
-    if (pom.includes("mybatis") && !stack.orm) { stack.orm = "mybatis"; stack.detected.push("mybatis"); }
-    if (pom.includes("jpa") || pom.includes("hibernate")) { if (!stack.orm) stack.orm = "jpa"; stack.detected.push("jpa"); }
-    if (pom.includes("postgresql") && !stack.database) stack.database = "postgresql";
-    if (pom.includes("mysql") && !stack.database) stack.database = "mysql";
-    if (pom.includes("oracle") && !stack.database) stack.database = "oracle";
+    if (!stack.orm && pom.includes("mybatis")) { stack.orm = "mybatis"; stack.detected.push("mybatis"); }
+    if (!stack.orm && (pom.includes("jpa") || pom.includes("hibernate"))) { stack.orm = "jpa"; stack.detected.push("jpa"); }
+    if (!stack.orm && pom.includes("exposed")) { stack.orm = "exposed"; stack.detected.push("exposed"); }
+    if (!stack.orm && pom.includes("jooq")) { stack.orm = "jooq"; stack.detected.push("jooq"); }
+    if (!stack.database && pom.includes("postgresql")) stack.database = "postgresql";
+    if (!stack.database && pom.includes("mysql")) stack.database = "mysql";
+    if (!stack.database && pom.includes("oracle")) stack.database = "oracle";
+    if (!stack.database && pom.includes("mongodb")) stack.database = "mongodb";
+    if (!stack.database && pom.includes("h2")) stack.database = "h2";
+    if (!stack.database && pom.includes("sqlite")) stack.database = "sqlite";
   }
 
   // ── Node.js ──
   if (fs.existsSync(path.join(ROOT, "package.json"))) {
-    const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf-8"));
+    let pkg;
+    try { pkg = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf-8")); }
+    catch { console.warn("    ⚠️  package.json parse error — skipping Node.js detection"); pkg = null; }
+    if (!pkg) return stack;
     stack.detected.push("package.json");
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
 
     if (!stack.language) stack.language = deps.typescript ? "typescript" : "javascript";
     if (deps.typescript) { stack.detected.push("typescript"); stack.languageVersion = deps.typescript.replace(/[^0-9.]/g, ""); }
 
-    // 프론트엔드
+    // Frontend
     if (deps.next) { stack.frontend = "nextjs"; stack.detected.push("next.js"); stack.frontendVersion = deps.next.replace(/[^0-9.]/g, ""); }
     else if (deps.react) { stack.frontend = "react"; stack.detected.push("react"); stack.frontendVersion = deps.react.replace(/[^0-9.]/g, ""); }
     else if (deps.vue) { stack.frontend = "vue"; stack.detected.push("vue"); stack.frontendVersion = deps.vue.replace(/[^0-9.]/g, ""); }
 
-    // 백엔드 프레임워크
+    // Backend framework
     if (deps.express && !stack.framework) { stack.framework = "express"; stack.detected.push("express"); }
     if (deps["@nestjs/core"]) { stack.framework = "nestjs"; stack.detected.push("nestjs"); stack.frameworkVersion = deps["@nestjs/core"].replace(/[^0-9.]/g, ""); }
 
@@ -101,7 +226,7 @@ async function detectStack() {
     if (deps.mysql2 && !stack.database) stack.database = "mysql";
     if (deps.mongodb && !stack.database) stack.database = "mongodb";
 
-    // 패키지 매니저
+    // Package manager
     stack.packageManager = fs.existsSync(path.join(ROOT, "pnpm-lock.yaml")) ? "pnpm"
       : fs.existsSync(path.join(ROOT, "yarn.lock")) ? "yarn" : "npm";
 
@@ -149,11 +274,16 @@ async function detectStack() {
   const ymls = await glob("**/application*.yml", { cwd: ROOT, absolute: true, ignore: ["**/node_modules/**"] });
   for (const y of ymls) {
     const c = fs.readFileSync(y, "utf-8");
-    if (c.includes("postgresql") && !stack.database) stack.database = "postgresql";
-    if (c.includes("mysql") && !stack.database) stack.database = "mysql";
-    if (c.includes("oracle") && !stack.database) stack.database = "oracle";
-    const pm = c.match(/port:\s*(\d+)/);
-    if (pm) stack.port = parseInt(pm[1]);
+    if (!stack.database && c.includes("postgresql")) stack.database = "postgresql";
+    if (!stack.database && c.includes("mysql")) stack.database = "mysql";
+    if (!stack.database && c.includes("oracle")) stack.database = "oracle";
+    if (!stack.database && c.includes("mongodb")) stack.database = "mongodb";
+    if (!stack.database && /\bh2\b/.test(c)) stack.database = "h2";
+    if (!stack.database && c.includes("sqlite")) stack.database = "sqlite";
+    if (!stack.port) {
+      const pm = c.match(/server:\s*\n\s*port:\s*(\d+)/) || c.match(/server\.port\s*[=:]\s*(\d+)/);
+      if (pm) stack.port = parseInt(pm[1]);
+    }
   }
 
   // .env
@@ -181,7 +311,7 @@ async function detectStack() {
     }
   }
 
-  // ── Config file fallback (모노레포: package.json에 없어도 설정 파일로 감지) ──
+  // ── Config file fallback (monorepo: detect from config files when not in package.json) ──
   if (!stack.frontend) {
     const nextConfigs = ["next.config.js", "next.config.mjs", "next.config.ts"];
     if (nextConfigs.some(c => fs.existsSync(path.join(ROOT, c)))) {
@@ -205,7 +335,7 @@ async function detectStack() {
   return stack;
 }
 
-// ─── 구조 스캔 (멀티스택) ────────────────────────────────
+// ─── Structure scan (multi-stack) ────────────────────────────────
 async function scanStructure(stack) {
   const backendDomains = [];
   const frontendDomains = [];
@@ -221,7 +351,7 @@ async function scanStructure(stack) {
     const domainMap = {};
     let detectedPattern = null;
 
-    // Pattern A: controller/{domain}/*.java (레이어 우선 — controller 아래에 도메인)
+    // Pattern A: controller/{domain}/*.java (layer-first — domain under controller)
     const controllersA = await glob("src/main/java/**/controller/*/*.java", { cwd: ROOT });
     for (const f of controllersA) {
       const m = f.match(/controller\/([^/]+)\//);
@@ -233,8 +363,8 @@ async function scanStructure(stack) {
     }
     if (Object.keys(domainMap).length > 0) detectedPattern = "A";
 
-    // Pattern B/D: {domain}/controller/*.java (도메인 우선 — 도메인 아래에 controller)
-    // D는 B의 확장: {module}/{domain}/controller/ — 동일 도메인명 충돌 시 module/domain 형태로 전환
+    // Pattern B/D: {domain}/controller/*.java (domain-first — controller under domain)
+    // D extends B: {module}/{domain}/controller/ — auto-upgrade to module/domain on name conflict
     if (!detectedPattern) {
       const controllersB = await glob("src/main/java/**/*/controller/*.java", { cwd: ROOT });
       const domainPaths = {};
@@ -249,11 +379,11 @@ async function scanStructure(stack) {
         }
       }
 
-      // 동일 도메인명이 여러 모듈에서 발견되면 module/domain 형태로 (Pattern D)
+      // If same domain name found in multiple modules, use module/domain form (Pattern D)
       for (const [d, entries] of Object.entries(domainPaths)) {
         const modules = [...new Set(entries.map(e => e.module).filter(Boolean))];
         if (modules.length > 1) {
-          // Pattern D: 충돌 — module/domain 형태로 등록
+          // Pattern D: conflict — register as module/domain
           for (const entry of entries) {
             const fullName = entry.module ? `${entry.module}/${d}` : d;
             if (!domainMap[fullName]) domainMap[fullName] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "D", modulePath: entry.module, domainName: d };
@@ -267,7 +397,7 @@ async function scanStructure(stack) {
       if (Object.keys(domainMap).length > 0) detectedPattern = domainMap[Object.keys(domainMap)[0]].pattern;
     }
 
-    // Pattern E: DDD/헥사고날 — {domain}/adapter/in/web/*.java 또는 {domain}/adapter/in/rest/*.java
+    // Pattern E: DDD/Hexagonal — {domain}/adapter/in/web/*.java or {domain}/adapter/in/rest/*.java
     if (!detectedPattern) {
       const controllersE = await glob("src/main/java/**/adapter/in/{web,rest}/*.java", { cwd: ROOT });
       for (const f of controllersE) {
@@ -281,7 +411,7 @@ async function scanStructure(stack) {
       if (Object.keys(domainMap).length > 0) detectedPattern = "E";
     }
 
-    // Pattern C: 플랫 구조 — controller/*.java (도메인 디렉토리 없음, 클래스명에서 도메인 추출)
+    // Pattern C: Flat structure — controller/*.java (no domain directory, extract domain from class name)
     if (!detectedPattern) {
       const controllersC = await glob("src/main/java/**/controller/*.java", { cwd: ROOT });
       for (const f of controllersC) {
@@ -295,8 +425,8 @@ async function scanStructure(stack) {
       if (Object.keys(domainMap).length > 0) detectedPattern = "C";
     }
 
-    // ── 보충 스캔: controller 없는 서비스 도메인 감지 ──
-    // core/delivery 처럼 service/mapper만 있고 controller가 없는 도메인 포착
+    // ── Supplementary scan: detect service-only domains without controllers ──
+    // Catch domains like core/delivery that have service/mapper but no controller
     if (detectedPattern === "B" || detectedPattern === "D" || !detectedPattern) {
       const serviceDirs = await glob("src/main/java/**/*/service/*.java", { cwd: ROOT });
       const mapperDirs = await glob("src/main/java/**/*/{mapper,repository}/*.java", { cwd: ROOT });
@@ -313,7 +443,7 @@ async function scanStructure(stack) {
       }
     }
 
-    // 각 도메인의 service/mapper/dto/xml 파일 스캔
+    // Scan service/mapper/dto/xml files for each domain
     for (const d of Object.keys(domainMap)) {
       const p = domainMap[d].pattern;
       const dn = domainMap[d].domainName || d;
@@ -332,7 +462,7 @@ async function scanStructure(stack) {
         mprGlob = `src/main/java/**/${d}/adapter/out/{persistence,repository}/*.java`;
         dtoGlob = `src/main/java/**/${d}/**/{dto,command,query}/**/*.java`;
       } else {
-        // Pattern C: 플랫 — 도메인명으로 파일명 매칭
+        // Pattern C: Flat — match domain name from file name
         const cap = d.charAt(0).toUpperCase() + d.slice(1);
         svcGlob = `src/main/java/**/service/${cap}*.java`;
         mprGlob = `src/main/java/**/{mapper,repository}/${cap}*.java`;
@@ -351,7 +481,7 @@ async function scanStructure(stack) {
       backendDomains.push({ name: d, type: "backend", ...domainMap[d], totalFiles: svc.length + mpr.length + dto.length + xml.length + domainMap[d].controllers });
     }
 
-    // ── Java 폴백: 위 글로브가 0개일 때 전체 .java 파일에서 직접 도메인 추출 ──
+    // ── Java fallback: extract domains directly from all .java files when glob returns 0 ──
     if (backendDomains.length === 0) {
       const allJava = await glob("**/*.java", { cwd: ROOT, ignore: ["**/node_modules/**", "**/build/**", "**/target/**", "**/test/**", "**/generated/**"] });
       const javaDomains = {};
@@ -363,11 +493,11 @@ async function scanStructure(stack) {
         const parts = f.replace(/\\/g, "/").split("/");
         for (let i = 0; i < parts.length - 1; i++) {
           if (layerNames.includes(parts[i]) && i > 0) {
-            // Pattern A 감지: .../{domain}/controller/... 또는 .../controller/{domain}/...
+            // Pattern A detection: .../{domain}/controller/... or .../controller/{domain}/...
             const prevDir = parts[i - 1];
             const nextDir = parts[i + 1];
 
-            // {domain}/layer/ 패턴 (도메인이 레이어 앞에)
+            // {domain}/layer/ pattern (domain before layer)
             if (!skipNames.includes(prevDir) && !layerNames.includes(prevDir) && !prevDir.includes(".") && !versionPattern.test(prevDir)) {
               if (!javaDomains[prevDir]) javaDomains[prevDir] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "B" };
               if (parts[i] === "controller") javaDomains[prevDir].controllers++;
@@ -375,7 +505,7 @@ async function scanStructure(stack) {
               else if (["mapper", "repository", "dao"].includes(parts[i])) javaDomains[prevDir].mappers++;
               else if (["dto", "vo"].includes(parts[i])) javaDomains[prevDir].dtos++;
             }
-            // layer/{domain}/ 패턴 (레이어가 도메인 앞에)
+            // layer/{domain}/ pattern (layer before domain)
             if (nextDir && !nextDir.endsWith(".java") && !skipNames.includes(nextDir) && !layerNames.includes(nextDir) && !versionPattern.test(nextDir)) {
               if (!javaDomains[nextDir]) javaDomains[nextDir] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "A" };
               if (parts[i] === "controller") javaDomains[nextDir].controllers++;
@@ -397,7 +527,191 @@ async function scanStructure(stack) {
     }
   }
 
-  // ── Node.js 백엔드 (Express/NestJS) — 프론트엔드 존재 여부와 무관하게 스캔 ──
+  // ── Kotlin (multi-module monorepo + CQRS support) ──
+  if (stack.language === "kotlin") {
+    // Scan all .kt files across all submodules
+    const ktFiles = await glob("**/src/main/kotlin/**/*.kt", {
+      cwd: ROOT,
+      ignore: ["**/node_modules/**", "**/build/**", "**/test/**", "**/generated/**"],
+    });
+
+    // Detect root package from first controller/service file
+    for (const f of ktFiles) {
+      const m = f.match(/src\/main\/kotlin\/(.+?)\/(controller|service|mapper|dto|entity|repository|adapter)/);
+      if (m) { rootPackage = m[1].replace(/\//g, "."); break; }
+    }
+
+    // Detect modules from directory structure (servers/*/ or direct submodules)
+    const moduleGlobs = [
+      "servers/*/*/src/main/kotlin/",     // servers/command/reservation-command-server/
+      "servers/*/src/main/kotlin/",        // servers/iam-server/
+      "*/src/main/kotlin/",                // shared-lib/ or integration-lib/
+    ];
+    const moduleSet = {};
+    for (const mg of moduleGlobs) {
+      const moduleDirs = await glob(mg, { cwd: ROOT });
+      for (const md of moduleDirs) {
+        const parts = md.replace(/\/src\/main\/kotlin\/$/, "").split("/");
+        const moduleName = parts[parts.length - 1]; // e.g., "reservation-command-server"
+        if (moduleSet[moduleName]) {
+          // Name conflict: use full relative path as key to avoid silent loss
+          const fullKey = md.replace(/\/src\/main\/kotlin\/$/, "").replace(/\//g, "__");
+          moduleSet[fullKey] = md;
+        } else {
+          moduleSet[moduleName] = md;
+        }
+      }
+    }
+
+    // Categorize modules and extract domains
+    const skipModules = ["build", "gradle", "buildSrc", ".gradle", "node_modules"];
+    const serverTypes = { command: "command", query: "query", bff: "bff", integration: "integration" };
+    const domainMap = {};
+
+    for (const [moduleName, modulePath] of Object.entries(moduleSet)) {
+      if (skipModules.some(s => moduleName.includes(s))) continue;
+
+      // Determine server type from module name
+      let serverType = "standalone";
+      for (const [key, val] of Object.entries(serverTypes)) {
+        if (moduleName.includes(key)) { serverType = val; break; }
+      }
+
+      // Extract domain name from module name
+      // e.g., "reservation-command-server" → "reservation"
+      // e.g., "pms-bff-server" → "pms"
+      // e.g., "iam-server" → "iam"
+      // e.g., "shared-lib" → "shared-lib"
+      // e.g., "common-query-server" → "common-query" (shared server, not a domain named "common")
+      let domainName = moduleName
+        .replace(/-(?:command|query|bff|integration|adapter)-server$/, "")
+        .replace(/-server$/, "")
+        .replace(/-lib$/, "-lib");
+
+      // Guard: if domain extraction resulted in a generic name that is likely a shared module
+      // (e.g., "common-query-server" → "common"), keep the full type qualifier
+      const genericNames = ["common", "shared", "base", "core", "global", "internal"];
+      if (genericNames.includes(domainName) && serverType !== "standalone") {
+        domainName = `${domainName}-${serverType}`;
+      }
+
+      // Scan files in this module (append "/" to prevent prefix overlap: e.g., reservation vs reservation-ext)
+      const modulePrefix = modulePath.replace(/\/$/, "").replace(/\/src\/main\/kotlin$/, "") + "/";
+      const moduleKtFiles = ktFiles.filter(f => f.startsWith(modulePrefix) || f === modulePrefix.slice(0, -1));
+      const controllers = moduleKtFiles.filter(f => /controller/i.test(f)).length;
+      const services = moduleKtFiles.filter(f => /service/i.test(f)).length;
+      const repositories = moduleKtFiles.filter(f => /repository|mapper/i.test(f)).length;
+      const dtos = moduleKtFiles.filter(f => /dto|vo|request|response|model/i.test(f) && !/repository|service|controller/i.test(f)).length;
+      const totalFiles = moduleKtFiles.length;
+
+      if (totalFiles === 0) continue;
+
+      const key = `${domainName}:${serverType}`;
+      domainMap[key] = {
+        name: domainName,
+        moduleName,
+        modulePath,
+        serverType,
+        controllers,
+        services,
+        repositories,
+        dtos,
+        totalFiles,
+      };
+    }
+
+    // Group by domain: merge command/query/bff of same domain
+    const domainGroups = {};
+    for (const [key, info] of Object.entries(domainMap)) {
+      const { name } = info;
+      if (!domainGroups[name]) {
+        domainGroups[name] = { name, type: "backend", modules: [], controllers: 0, services: 0, repositories: 0, dtos: 0, totalFiles: 0, serverTypes: [] };
+      }
+      const dg = domainGroups[name];
+      dg.modules.push(info.moduleName);
+      dg.controllers += info.controllers;
+      dg.services += info.services;
+      dg.repositories += info.repositories;
+      dg.dtos += info.dtos;
+      dg.totalFiles += info.totalFiles;
+      if (!dg.serverTypes.includes(info.serverType)) dg.serverTypes.push(info.serverType);
+    }
+
+    // Push to backendDomains
+    for (const dg of Object.values(domainGroups)) {
+      backendDomains.push({
+        name: dg.name,
+        type: "backend",
+        controllers: dg.controllers,
+        services: dg.services,
+        mappers: dg.repositories,
+        dtos: dg.dtos,
+        totalFiles: dg.totalFiles,
+        modules: dg.modules,
+        serverTypes: dg.serverTypes,
+        pattern: "kotlin-multimodule",
+      });
+    }
+
+    // Also scan shared libraries as special domains
+    const libDirs = await glob("{shared-lib,integration-lib,*-lib}/src/main/kotlin/", { cwd: ROOT });
+    for (const ld of libDirs) {
+      const libName = ld.split("/")[0];
+      if (domainGroups[libName]) continue; // Already captured
+      const libFiles = ktFiles.filter(f => f.startsWith(libName));
+      if (libFiles.length > 0) {
+        backendDomains.push({
+          name: libName,
+          type: "backend",
+          controllers: 0,
+          services: libFiles.filter(f => /service/i.test(f)).length,
+          mappers: 0,
+          dtos: libFiles.filter(f => /dto|vo|model/i.test(f)).length,
+          totalFiles: libFiles.length,
+          modules: [libName],
+          serverTypes: ["library"],
+          pattern: "kotlin-library",
+        });
+      }
+    }
+
+    // Resolve shared query modules: redistribute internal domains to actual domain entries
+    resolveSharedQueryDomains(backendDomains, ktFiles);
+
+    // ── Kotlin single-module fallback (no multi-module structure detected) ──
+    if (backendDomains.length === 0 && ktFiles.length > 0) {
+      const ktDomains = {};
+      const skipNames = ["common", "config", "util", "utils", "base", "shared", "global", "framework", "infra", "main", "generated", "build"];
+      const layerKw = ["controller", "service", "repository", "mapper", "dao", "dto", "vo", "entity", "aggregate", "adapter"];
+      for (const f of ktFiles) {
+        const parts = f.replace(/\\/g, "/").split("/");
+        for (let i = 0; i < parts.length - 1; i++) {
+          if (layerKw.includes(parts[i].toLowerCase())) {
+            // domain/layer/ pattern
+            if (i > 0) {
+              const d = parts[i - 1].toLowerCase();
+              if (!skipNames.includes(d) && !layerKw.includes(d) && d.length > 1 && d !== "kotlin") {
+                if (!ktDomains[d]) ktDomains[d] = { controllers: 0, services: 0, mappers: 0, dtos: 0, totalFiles: 0 };
+                if (parts[i] === "controller") ktDomains[d].controllers++;
+                else if (parts[i] === "service") ktDomains[d].services++;
+                else if (["repository", "mapper", "dao"].includes(parts[i])) ktDomains[d].mappers++;
+                else if (["dto", "vo", "entity"].includes(parts[i])) ktDomains[d].dtos++;
+                ktDomains[d].totalFiles++;
+              }
+            }
+            break;
+          }
+        }
+      }
+      for (const [d, data] of Object.entries(ktDomains)) {
+        if (data.totalFiles > 0) {
+          backendDomains.push({ name: d, type: "backend", ...data, pattern: "kotlin-single" });
+        }
+      }
+    }
+  }
+
+  // ── Node.js backend (Express/NestJS) — scan regardless of frontend presence ──
   if ((stack.language === "typescript" || stack.language === "javascript") && stack.framework) {
     const nestModules = await glob("src/modules/*/", { cwd: ROOT });
     const srcDirs = nestModules.length > 0 ? nestModules : await glob("src/*/", { cwd: ROOT });
@@ -417,7 +731,7 @@ async function scanStructure(stack) {
 
   // ── Next.js/React/Vue ──
   if (stack.frontend === "nextjs" || stack.frontend === "react" || stack.frontend === "vue") {
-    // App Router / Pages Router 도메인
+    // App Router / Pages Router domains
     const allDirs = [
       ...await glob("{app,src/app}/*/", { cwd: ROOT }),
       ...await glob("{pages,src/pages}/*/", { cwd: ROOT }),
@@ -456,7 +770,7 @@ async function scanStructure(stack) {
       }
     }
 
-    // components/* (기존)
+    // components/* (existing)
     const compDirs = await glob("{src/,}components/*/", { cwd: ROOT });
     for (const dir of compDirs) {
       const name = path.basename(dir);
@@ -467,7 +781,7 @@ async function scanStructure(stack) {
       }
     }
 
-    // ── 폴백: 위 스캐너로 0개일 때 page.tsx/index.tsx 위치에서 직접 도메인 추출 ──
+    // ── Fallback: extract domains directly from page.tsx/index.tsx locations when scanners return 0 ──
     if (frontendDomains.length === 0) {
       const pageFiles = await glob("**/page.{tsx,jsx}", { cwd: ROOT, ignore: ["**/node_modules/**", "**/.next/**"] });
       const domainSet = {};
@@ -486,7 +800,7 @@ async function scanStructure(stack) {
           }
         }
       }
-      // client.tsx도 카운트
+      // Count client.tsx as well
       const clientFiles = await glob("**/client.{tsx,jsx}", { cwd: ROOT, ignore: ["**/node_modules/**", "**/.next/**"] });
       for (const f of clientFiles) {
         const parts = f.replace(/\\/g, "/").split("/");
@@ -507,7 +821,7 @@ async function scanStructure(stack) {
         });
       }
 
-      // widgets/features/entities도 직접 스캔 (글로브 폴백)
+      // Also scan widgets/features/entities directly (glob fallback)
       for (const layer of ["widgets", "features", "entities"]) {
         const layerFiles = await glob(`**/${layer}/*/**/*.{tsx,jsx,ts,js}`, { cwd: ROOT, ignore: ["**/node_modules/**", "**/.next/**", "**/*.spec.*", "**/*.test.*"] });
         const layerDomains = {};
@@ -537,9 +851,9 @@ async function scanStructure(stack) {
       if (dir === "." || dir.includes("venv")) continue;
       const name = path.basename(dir);
       const appFiles = await glob(`${dir}/*.py`, { cwd: ROOT });
-      const views = appFiles.filter(f => f.includes("views")).length;
-      const models = appFiles.filter(f => f.includes("models")).length;
-      const serializers = appFiles.filter(f => f.includes("serializers")).length;
+      const views = appFiles.filter(x => x.includes("views")).length;
+      const models = appFiles.filter(x => x.includes("models")).length;
+      const serializers = appFiles.filter(x => x.includes("serializers")).length;
       backendDomains.push({ name, type: "backend", views, models, serializers, totalFiles: appFiles.length });
     }
   }
@@ -567,7 +881,7 @@ async function scanStructure(stack) {
     }
   }
 
-  // 프론트엔드 카운트
+  // Frontend count
   const frontend = { exists: false, components: 0, pages: 0, hooks: 0 };
   if (stack.frontend) {
     frontend.exists = true;
@@ -576,7 +890,7 @@ async function scanStructure(stack) {
     frontend.hooks = (await glob("{src/,}**/hooks/**/*.{ts,js}", { cwd: ROOT, ignore: ["**/node_modules/**"] })).length;
   }
 
-  // App Router RSC/Client 전체 통계 (project-analysis.json용)
+  // App Router RSC/Client overall stats (for project-analysis.json)
   if (stack.frontend === "nextjs") {
     const allClientFiles = await glob("{app,src/app}/**/client.{tsx,ts,jsx,js}", { cwd: ROOT });
     const allPageFiles = await glob("{app,src/app}/**/page.{tsx,ts,jsx,js}", { cwd: ROOT });
@@ -587,7 +901,7 @@ async function scanStructure(stack) {
     frontend.rscPattern = allClientFiles.length > 0;
   }
 
-  // 전체 도메인 = 백엔드 + 프론트엔드 (type 태그 포함)
+  // All domains = backend + frontend (with type tags)
   const allDomains = [
     ...backendDomains.sort((a, b) => b.totalFiles - a.totalFiles),
     ...frontendDomains.sort((a, b) => b.totalFiles - a.totalFiles),
@@ -596,7 +910,201 @@ async function scanStructure(stack) {
   return { domains: allDomains, backendDomains, frontendDomains, rootPackage, frontend };
 }
 
-// ─── 도메인 그룹 분할 (타입별) ──────────────────────────
+// ─── Resolve shared query modules ────────────────────────────────
+// When a shared query module (e.g., common-query-server) contains controllers/services
+// for multiple domains, extract the actual domains and merge them into existing entries.
+// Supports two extraction patterns:
+//   A) Package-based: .../kotlin/com/company/.../DOMAIN/controller/XxxController.kt
+//   B) Class-name-based: .../controller/ReservationQueryController.kt → "reservation"
+// Safety: if no shared modules are found, this function does nothing (no-op).
+function resolveSharedQueryDomains(backendDomains, ktFiles) {
+  const genericNames = ["common", "shared", "base", "core", "global"];
+  const layerNames = new Set([
+    "controller", "service", "repository", "mapper", "api", "handler",
+    "dto", "model", "entity", "config", "configuration", "util", "utils",
+    "infra", "infrastructure", "framework", "common", "shared", "base",
+    "core", "global", "internal", "external", "exception", "interceptor",
+    "filter", "converter", "event", "listener", "client", "feign",
+    "adapter", "port", "domain", "application", "presentation",
+    "persistence", "web", "rest", "grpc", "query", "command",
+    "aggregate", "aggregator", "vo", "valueobject",
+  ]);
+  const skipPackages = new Set([
+    "com", "org", "net", "io", "kr", "jp", "cn", "de", "fr", "uk", "us",
+    "dev", "app", "main", "server", "backend", "project", "kotlin",
+  ]);
+  const classSuffixes = new Set([
+    "Controller", "Service", "Repository", "Mapper", "Handler", "Api",
+    "Query", "Command", "Read", "Write", "Get", "Find", "List", "Search",
+    "Admin", "Dto", "Request", "Response", "Entity", "Model", "Impl",
+    "Factory", "Builder", "Adapter", "Client", "Facade", "Provider",
+  ]);
+
+  // Find shared modules: generic name + query server type
+  const sharedModules = backendDomains.filter(d =>
+    d.pattern === "kotlin-multimodule" &&
+    d.serverTypes && d.serverTypes.includes("query") &&
+    genericNames.some(g => d.name.startsWith(g))
+  );
+  if (sharedModules.length === 0) return;
+
+  // Existing domain names for Pattern B-1 matching (longest-first for greedy match)
+  const existingDomains = backendDomains
+    .filter(d => !sharedModules.includes(d) && d.pattern === "kotlin-multimodule")
+    .map(d => d.name)
+    .sort((a, b) => b.length - a.length);
+
+  for (const shared of sharedModules) {
+    const moduleNames = shared.modules || [];
+    const sharedKtFiles = ktFiles.filter(f =>
+      moduleNames.some(m => f.includes(`/${m}/`) || f.startsWith(`${m}/`))
+    );
+    if (sharedKtFiles.length === 0) continue;
+
+    const domainFileMap = {}; // { domainName: [filePaths] }
+
+    for (const filePath of sharedKtFiles) {
+      let domain = null;
+      const parts = filePath.replace(/\\/g, "/").split("/");
+
+      // ── Pattern A: Package-based ──
+      // Looks for: .../kotlin/com/company/[project/]DOMAIN/LAYER/File.kt
+      // Uses depth >= 3 from kotlin/ to skip base package segments
+      const kotlinIdx = parts.findIndex(p => p === "kotlin");
+      if (kotlinIdx >= 0) {
+        for (let i = kotlinIdx + 1; i < parts.length - 1; i++) {
+          if (layerNames.has(parts[i].toLowerCase())) {
+            if (i - 1 > kotlinIdx) {
+              const candidate = parts[i - 1].toLowerCase();
+              const depth = (i - 1) - kotlinIdx; // distance from kotlin/
+              if (
+                depth >= 3 &&
+                !layerNames.has(candidate) &&
+                !skipPackages.has(candidate) &&
+                candidate.length > 2
+              ) {
+                domain = candidate;
+              }
+            }
+            break; // only check first layer directory encountered
+          }
+        }
+      }
+
+      // ── Pattern B-1: Match class name against existing domain names ──
+      if (!domain) {
+        const fileName = parts[parts.length - 1].replace(/\.kt$/, "").toLowerCase();
+        for (const ed of existingDomains) {
+          const normalized = ed.replace(/-/g, "");
+          if (fileName.startsWith(normalized) && fileName.length > normalized.length) {
+            domain = ed;
+            break;
+          }
+        }
+      }
+
+      // ── Pattern B-2: Extract from PascalCase class name ──
+      if (!domain) {
+        const fileName = parts[parts.length - 1].replace(/\.kt$/, "");
+        const words = fileName.match(/[A-Z][a-z]+|[A-Z]+(?=[A-Z][a-z]|$)/g);
+        if (words && words.length >= 2) {
+          const domainWords = [];
+          for (const w of words) {
+            if (classSuffixes.has(w)) break;
+            domainWords.push(w);
+          }
+          if (domainWords.length > 0) {
+            const extracted = domainWords.join("").toLowerCase();
+            if (
+              !genericNames.includes(extracted) &&
+              !skipPackages.has(extracted) &&
+              extracted.length > 2
+            ) {
+              domain = extracted;
+            }
+          }
+        }
+      }
+
+      if (domain) {
+        if (!domainFileMap[domain]) domainFileMap[domain] = [];
+        domainFileMap[domain].push(filePath);
+      }
+    }
+
+    // ── Merge extracted domains into backendDomains ──
+    let distributedFiles = 0;
+    for (const [domain, files] of Object.entries(domainFileMap)) {
+      // Find matching existing domain (exact or normalized)
+      const existing = backendDomains.find(d =>
+        d !== shared &&
+        (d.name === domain || d.name.replace(/-/g, "") === domain.replace(/-/g, ""))
+      );
+
+      const ctrlCount = files.filter(f =>
+        /\/controller\//i.test(f) || /Controller\.kt$/i.test(f)
+      ).length;
+      const svcCount = files.filter(f =>
+        /\/service\//i.test(f) || /Service\.kt$/i.test(f)
+      ).length;
+      const repoCount = files.filter(f =>
+        /\/repository\//i.test(f) || /\/mapper\//i.test(f) ||
+        /Repository\.kt$/i.test(f) || /Mapper\.kt$/i.test(f)
+      ).length;
+      const dtoCount = files.filter(f =>
+        (/\/dto\//i.test(f) || /\/vo\//i.test(f) || /Dto\.kt$/i.test(f) ||
+         /Vo\.kt$/i.test(f) || /Request\.kt$/i.test(f) || /Response\.kt$/i.test(f)) &&
+        !/\/controller\//i.test(f) && !/\/service\//i.test(f) &&
+        !/\/repository\//i.test(f)
+      ).length;
+
+      if (existing) {
+        // Merge into existing domain
+        if (!existing.modules) existing.modules = [];
+        for (const m of moduleNames) {
+          if (!existing.modules.includes(m)) existing.modules.push(m);
+        }
+        if (!existing.serverTypes) existing.serverTypes = [];
+        if (!existing.serverTypes.includes("query")) existing.serverTypes.push("query");
+        existing.controllers += ctrlCount;
+        existing.services += svcCount;
+        if (existing.mappers != null) existing.mappers += repoCount;
+        existing.dtos += dtoCount;
+        existing.totalFiles += files.length;
+      } else {
+        // Create new domain entry
+        backendDomains.push({
+          name: domain,
+          type: "backend",
+          controllers: ctrlCount,
+          services: svcCount,
+          mappers: repoCount,
+          dtos: dtoCount,
+          totalFiles: files.length,
+          modules: [...moduleNames],
+          serverTypes: ["query"],
+          pattern: "kotlin-multimodule",
+          resolvedFrom: shared.name,
+        });
+      }
+      distributedFiles += files.length;
+    }
+
+    // Adjust shared module: keep only undistributed files
+    if (distributedFiles > 0) {
+      shared.totalFiles = Math.max(0, shared.totalFiles - distributedFiles);
+      shared.resolvedDomains = Object.keys(domainFileMap);
+      if (shared.totalFiles === 0) shared._resolved = true;
+    }
+  }
+
+  // Remove fully resolved shared entries (all files distributed)
+  for (let i = backendDomains.length - 1; i >= 0; i--) {
+    if (backendDomains[i]._resolved) backendDomains.splice(i, 1);
+  }
+}
+
+// ─── Domain group splitting (per type) ──────────────────────────
 function splitDomainGroups(domains, type, template) {
   const MAX_FILES_PER_GROUP = 40;
   const MAX_DOMAINS_PER_GROUP = 4;
@@ -620,7 +1128,7 @@ function splitDomainGroups(domains, type, template) {
   return groups;
 }
 
-// ─── 활성 도메인 결정 ───────────────────────────────────
+// ─── Determine active domains ───────────────────────────────────
 function determineActiveDomains(stack) {
   const isBackend = stack.framework && !["nextjs", "react", "vue"].includes(stack.framework);
   return {
@@ -634,24 +1142,25 @@ function determineActiveDomains(stack) {
   };
 }
 
-// ─── 템플릿 선택 (멀티스택) ──────────────────────────────
+// ─── Template selection (multi-stack) ──────────────────────────────
 function selectTemplates(stack) {
   const templates = { backend: null, frontend: null };
 
-  // 백엔드 템플릿
-  if (stack.language === "java") templates.backend = "java-spring";
+  // Backend template
+  if (stack.language === "kotlin") templates.backend = "kotlin-spring";
+  else if (stack.language === "java") templates.backend = "java-spring";
   else if (stack.framework === "express" || stack.framework === "nestjs") templates.backend = "node-express";
   else if (stack.framework === "django") templates.backend = "python-django";
   else if (stack.framework === "fastapi" || stack.framework === "flask") templates.backend = "python-fastapi";
   else if (stack.language === "typescript" || stack.language === "javascript") templates.backend = "node-express";
   else if (stack.language === "python") templates.backend = "python-fastapi";
 
-  // 프론트엔드 템플릿
+  // Frontend template
   if (stack.frontend === "nextjs" || stack.frontend === "react" || stack.frontend === "vue") {
     templates.frontend = "node-nextjs";
   }
 
-  // 프론트엔드만 있고 백엔드가 없는 순수 프론트엔드 프로젝트
+  // Pure frontend project with no backend
   if (!templates.backend && templates.frontend) {
     templates.backend = null;
   }
@@ -659,28 +1168,43 @@ function selectTemplates(stack) {
   return templates;
 }
 
-// ─── 프롬프트 동적 생성 (멀티스택) ──────────────────────
-function generatePrompts(templates) {
+// ─── Dynamic prompt generation (multi-stack) ──────────────────────
+function generatePrompts(templates, lang) {
   const commonDir  = path.join(TEMPLATES_DIR, "common");
   const headerPath = path.join(commonDir, "header.md");
   const footerPath = path.join(commonDir, "pass3-footer.md");
+  const langPath   = path.join(commonDir, "lang-instructions.json");
 
   const header = fs.existsSync(headerPath) ? fs.readFileSync(headerPath, "utf-8") : "";
   const footer = fs.existsSync(footerPath) ? fs.readFileSync(footerPath, "utf-8") : "";
 
+  // Load language instruction for Pass 3 (analysis passes stay English)
+  let langInstruction = "";
+  if (lang && lang !== "en" && fs.existsSync(langPath)) {
+    try {
+      const langData = JSON.parse(fs.readFileSync(langPath, "utf-8"));
+      langInstruction = langData.instructions[lang] || "";
+      if (langInstruction) {
+        console.log(`    🌐 Language: ${langData.labels[lang]} (Pass 3 output)`);
+      }
+    } catch (e) {
+      console.warn(`    ⚠️  lang-instructions.json parse error: ${e.message}`);
+    }
+  }
+
   function readTemplate(templateName, passName) {
     const src = path.join(TEMPLATES_DIR, templateName, `${passName}.md`);
     if (!fs.existsSync(src)) return null;
     let body = fs.readFileSync(src, "utf-8");
-    body = body.replace(/^프로젝트 루트 경로:.*\n이 경로를 기준으로.*\n\n?---\n\n?/s, "");
-    body = body.replace(/\n완료 후 반드시 아래 명령을 순서대로 실행:[\s\S]*$/m, "");
+    body = body.replace(/^Project root path:.*\nInterpret all file paths.*\n\n?---\n\n?/s, "");
+    body = body.replace(/\nAfter completion, run the following commands in order:[\s\S]*$/m, "");
     return body;
   }
 
   const activeTemplates = [templates.backend, templates.frontend].filter(Boolean);
   const primaryTemplate = templates.backend || templates.frontend;
 
-  // ─── Pass 1: 타입별 별도 프롬프트 ──────────────────────
+  // ─── Pass 1: Separate prompts per type ──────────────────────
   for (const tmpl of activeTemplates) {
     const type = tmpl === templates.frontend ? "frontend" : "backend";
     const body = readTemplate(tmpl, "pass1");
@@ -691,7 +1215,7 @@ function generatePrompts(templates) {
     }
   }
 
-  // 단일 스택 하위 호환: pass1-prompt.md도 생성 (primary 기준)
+  // Single-stack backward compat: also generate pass1-prompt.md (primary-based)
   if (primaryTemplate) {
     const body = readTemplate(primaryTemplate, "pass1");
     if (body) {
@@ -699,7 +1223,7 @@ function generatePrompts(templates) {
     }
   }
 
-  // ─── Pass 2: 단일 프롬프트 (primary 기준, 모든 pass1 결과를 머지) ──
+  // ─── Pass 2: Single prompt (primary-based, merges all pass1 results) ──
   if (primaryTemplate) {
     const body = readTemplate(primaryTemplate, "pass2");
     if (body) {
@@ -708,20 +1232,20 @@ function generatePrompts(templates) {
     }
   }
 
-  // ─── Pass 3: 통합 프롬프트 (백엔드 + 프론트엔드 결합) ──
+  // ─── Pass 3: Combined prompt (backend + frontend merged) ──
   if (primaryTemplate) {
     const primaryBody = readTemplate(primaryTemplate, "pass3");
     let combinedBody = primaryBody || "";
 
-    // 멀티스택: 프론트엔드 pass3의 고유 섹션을 백엔드 pass3에 병합
+    // Multi-stack: merge frontend-specific sections from frontend pass3 into backend pass3
     if (templates.backend && templates.frontend && templates.backend !== templates.frontend) {
       const frontendBody = readTemplate(templates.frontend, "pass3");
       if (frontendBody) {
         combinedBody += "\n\n---\n\n";
-        combinedBody += "# 추가: 프론트엔드 생성 대상 (자동 감지됨)\n\n";
-        combinedBody += "위 백엔드 표준에 더해, 아래 프론트엔드 표준도 함께 생성해줘.\n";
-        combinedBody += "pass2-merged.json의 프론트엔드 분석 결과를 참조할 것.\n\n";
-        // 프론트엔드 pass3에서 standard 섹션만 추출 (CLAUDE.md, guide 등 중복 제외)
+        combinedBody += "# Additional: Frontend generation targets (auto-detected)\n\n";
+        combinedBody += "In addition to the backend standards above, also generate the following frontend standards.\n";
+        combinedBody += "Reference the frontend analysis results in pass2-merged.json.\n\n";
+        // Extract only standard sections from frontend pass3 (exclude CLAUDE.md, guide duplicates)
         const frontendSections = frontendBody
           .split(/\n(?=\d+\.\s)/)
           .filter(s => /frontend|component|page|routing|data.fetch|state|styling/i.test(s))
@@ -733,12 +1257,12 @@ function generatePrompts(templates) {
     }
 
     const dst = path.join(GENERATED_DIR, "pass3-prompt.md");
-    fs.writeFileSync(dst, header + combinedBody.trimEnd() + "\n" + footer);
+    fs.writeFileSync(dst, header + langInstruction + combinedBody.trimEnd() + "\n" + footer);
     console.log(`    ✅ pass3-prompt.md${templates.frontend && templates.backend ? " (multi-stack combined)" : ""}`);
   }
 }
 
-// ─── 메인 ───────────────────────────────────────────────
+// ─── Main ───────────────────────────────────────────────
 async function main() {
   console.log("\n╔══════════════════════════════════════╗");
   console.log("║  ClaudeOS-Core — Plan Installer       ║");
@@ -746,7 +1270,7 @@ async function main() {
 
   ensureDir(GENERATED_DIR);
 
-  // Phase 1: 스택 감지
+  // Phase 1: Stack detection
   console.log("  [Phase 1] Detecting stack...");
   const stack = await detectStack();
   console.log(`    Language:    ${stack.language || "unknown"} ${stack.languageVersion || ""}`);
@@ -756,7 +1280,7 @@ async function main() {
   console.log(`    ORM:         ${stack.orm || "none"}`);
   console.log(`    PackageMgr:  ${stack.packageManager || "none"}\n`);
 
-  // Phase 2: 구조 스캔
+  // Phase 2: Structure scan
   console.log("  [Phase 2] Scanning structure...");
   const { domains, backendDomains, frontendDomains, rootPackage, frontend } = await scanStructure(stack);
   console.log(`    Backend:     ${backendDomains.length} domains`);
@@ -766,7 +1290,7 @@ async function main() {
   if (frontend.exists) console.log(`    Components:  ${frontend.components} components, ${frontend.pages} pages, ${frontend.hooks} hooks`);
   console.log();
 
-  // Phase 3: 템플릿 선택 (멀티스택)
+  // Phase 3: Template selection (multi-stack)
   console.log("  [Phase 3] Selecting templates...");
   const templates = selectTemplates(stack);
   const isMultiStack = !!(templates.backend && templates.frontend);
@@ -776,7 +1300,7 @@ async function main() {
   else console.log(`    Mode:        Single-stack`);
   console.log();
 
-  // Phase 4: 도메인 그룹 분할 (타입별)
+  // Phase 4: Domain group splitting (per type)
   console.log("  [Phase 4] Splitting domain groups...");
   const allGroups = [];
   if (templates.backend && backendDomains.length > 0) {
@@ -787,7 +1311,7 @@ async function main() {
     const fg = splitDomainGroups(frontendDomains, "frontend", templates.frontend);
     allGroups.push(...fg);
   }
-  // passNum 재할당
+  // Reassign passNum
   allGroups.forEach((g, i) => { g.passNum = i + 1; });
   allGroups.forEach((g, i) => {
     const icon = g.type === "backend" ? "⚙️" : "🎨";
@@ -795,7 +1319,7 @@ async function main() {
   });
   console.log();
 
-  // Phase 5: 활성 도메인
+  // Phase 5: Active domains
   console.log("  [Phase 5] Active domains...");
   const active = determineActiveDomains(stack);
   Object.entries(active).forEach(([k, v]) => {
@@ -803,15 +1327,17 @@ async function main() {
   });
   console.log();
 
-  // Phase 6: 프롬프트 생성 (멀티스택)
-  console.log(`  [Phase 6] Generating prompts...`);
-  generatePrompts(templates);
+  // Phase 6: Prompt generation (multi-stack)
+  const lang = process.env.CLAUDEOS_LANG || "en";
+  console.log(`  [Phase 6] Generating prompts (lang: ${lang})...`);
+  generatePrompts(templates, lang);
   console.log();
 
-  // 저장: project-analysis.json
+  // Save: project-analysis.json
   const defaultPort = stack.framework === "fastapi" || stack.framework === "django" ? 8000 : 8080;
   const analysis = {
     analyzedAt: new Date().toISOString(),
+    lang,
     stack: { ...stack, port: stack.port || defaultPort },
     templates,
     isMultiStack,
@@ -831,7 +1357,7 @@ async function main() {
   fs.writeFileSync(path.join(GENERATED_DIR, "project-analysis.json"), JSON.stringify(analysis, null, 2));
   console.log("  💾 project-analysis.json saved");
 
-  // 저장: domain-groups.json
+  // Save: domain-groups.json
   const domainGroups = {
     generatedAt: new Date().toISOString(),
     isMultiStack,