claudeos-core 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,6 +1,65 @@
 # Changelog
 
-## [1.1.0] — 2026-04
+## [1.2.0] — 2026-04-01
+
+### Added
+- **Multi-language output (i18n)** — `--lang` parameter selects output language for all generated files
+  - 10 languages supported: en, ko, zh-CN, ja, es, vi, hi, ru, fr, de
+  - Analysis (Pass 1-2) remains in English; generated files (Pass 3) are in selected language
+  - Interactive language selection when `--lang` is omitted
+  - Language instruction injected into Pass 3 prompt via `lang-instructions.json` template
+  - Code syntax, JSON keys, frontmatter keys stay in English; only documentation text is localized
+  - `project-analysis.json` now includes `lang` field
+  - `content-validator` updated with language-aware section keyword validation (10 languages)
+  - `pass-json-validator` now validates and displays `lang` field
+  - `bootstrap.sh` supports `--lang` parameter with interactive fallback
+- **Kotlin / Spring Boot support** — Dedicated `kotlin-spring` template (pass1/pass2/pass3)
+  - Kotlin-specific analysis: data class, sealed class, coroutines, extension functions, MockK, Kotest, kotlin-logging
+  - 12 analysis categories, 95 sub-items in Pass 1 (vs Java's 10/59)
+  - 14 merge categories in Pass 2 (vs Java's 12)
+  - 14 CRUD scaffold sub-skills in Pass 3 (vs Java's 8)
+- **CQRS architecture auto-detection** — Detects `command`/`query`/`bff`/`integration` from module names in `settings.gradle(.kts)`
+- **BFF (Backend For Frontend) analysis** — Feign Client patterns, response composition, error propagation, inter-module communication
+- **Gradle multi-module monorepo scanning** — `**/src/main/kotlin/**/*.kt` across all submodules, regardless of nesting depth
+- **Module type classification** — command, query, bff, integration, standalone, library
+- **Domain grouping across modules** — Same domain in Command + Query modules merged into single domain for analysis
+- **Shared query module resolution** — `common-query-server` and similar shared query modules are redistributed to actual domains (Pattern A: package-based, Pattern B: class-name-based extraction)
+- **VO (Value Object) pattern support** — DTO vs VO distinction, value class VO, immutability rules, VO location analysis
+- **Aggregate / Aggregate Root pattern support** — DDD aggregate boundary definition, Aggregate Root identification, repository-per-aggregate, domain event publishing, inter-aggregate references
+- **Aggregator service pattern support** — Aggregator vs BFF distinction, internal service aggregation analysis
+- **Shared library detection** — `shared-lib`, `integration-lib`, `*-lib` detected as special domains
+- **`build.gradle.kts` support** — Kotlin DSL build files detected alongside Groovy DSL
+- **Submodule Kotlin fallback** — If root build file doesn't have Kotlin plugin, checks up to 5 submodule build files
+- **Installation options expanded** — Added `npm install -g` and `npm install --save-dev` options in all 10 READMEs
+- **Manual step-by-step installation** — 8-step guide added to all 10 READMEs
+- **Full English localization** — All JS comments, console messages, pass prompts, and bootstrap.sh translated to English
+
+### Changed
+- `detectStack()` refactored: unified `build.gradle` / `build.gradle.kts` detection path
+- `selectTemplates()` now routes `kotlin` → `kotlin-spring` before Java fallback
+- `plan-validator` output file renamed `plan-manifest.json` → `plan-sync-status.json` (avoids overwriting manifest-generator output)
+- `sync-checker` exit code: now exits 1 only for orphaned files (actual breakage), exits 0 for unregistered files (informational)
+- `import-linter` now scans `database/` and `mcp-guide/` directories (aligned with other tools)
+- `import-graph.json` now includes imports from all 6 directories (was rules/ only)
+- Java `DTO/Entity` analysis category renamed to `DTO/VO/Entity` with VO pattern support added
+
+### Fixed
+- **Security**: Eliminated shell pipe command injection in `cli.js` (`runClaudePrompt` now uses stdin `input` option)
+- **Security**: Fixed Perl code injection in `bootstrap.sh` (domain list now passed via `$ENV{}`)
+- **Security**: Added Bash version guard in `bootstrap.sh` (prevents silent failure when run with `sh`)
+- **Security**: Windows `escapeShellArg` now handles `%`, `^`, `&`, `|`, `<`, `>`, `!` metacharacters
+- **Kotlin single-module fallback**: Projects without `settings.gradle` or `servers/` directory now detect domains from `src/main/kotlin/` (previously returned 0 domains)
+- **plan-validator `--execute`**: Now creates `.bak` backup before overwriting files
+- **Spring Boot version detection**: Added 3 regex patterns for modern Gradle DSL (`plugins {}`, `platform()`)
+- **Port detection**: Now matches only `server.port` (was matching any `port:` including database/Redis ports)
+- **Nested code fence handling**: `plan-validator` now tracks nesting depth to avoid false closing fence detection
+- **stale-report.json crash**: All 4 tools now wrap `JSON.parse` in try/catch (prevents cascade crash on corrupted file)
+- **package.json parse error**: `detectStack()` now catches malformed `package.json` instead of crashing
+- **Module path prefix overlap**: Kotlin module scan appends `/` to prevent `reservation` matching `reservation-ext`
+- **Acronym class names**: `resolveSharedQueryDomains` now handles `IAM`, `BFF` style names
+- `.gitignore`: Added `.env*` pattern, removed redundant entry
+
+## [1.1.0] — 2026-04-01
 
 ### Added
 - **Java 5-pattern domain detection** (A→B/D→E→C fallback):
@@ -14,7 +73,7 @@
 - **RSC/Client component detection**: Counts `client.tsx` files, tracks RSC+Client split pattern per domain
 - **Config file fallback**: Detect Next.js/Vite/Nuxt from config files when framework not in package.json (monorepo support)
 - **Windows glob compatibility**: Direct file scan fallback for Java and Frontend when glob patterns fail on Windows
-- **Pipe-based prompt delivery**: Write prompt to temp file and pipe to `claude -p` to bypass Windows 8191-char command-line limit
+- **Stdin-based prompt delivery**: Pass prompt via `execSync` `input` option to `claude -p` (no shell pipe, no temp file — secure and cross-platform)
 - **8 language READMEs**: Chinese, Japanese, Spanish, Vietnamese, Hindi, Russian, French, German
 - **Monorepo Support section** in all 10 READMEs (Turborepo, Nx, Lerna, pnpm workspaces)
 - **Cross-language navigation links** in all READMEs (Korean last position)
@@ -24,7 +83,7 @@
 - `frontend` variable reference before initialization (RSC stats)
 - npm bin path warning (`npm pkg fix`)
 
-## [1.0.0] — 2025
+## [1.0.0] — 2025-12-01
 
 ### Added
 - 3-Pass pipeline: Deep analysis → Merge → Generate

package/CONTRIBUTING.md

@@ -14,6 +14,7 @@ Thank you for your interest in contributing! Here's how you can help.
 
 - ~~Monorepo deep support~~ — Implemented (Turborepo, Nx, Lerna, pnpm workspaces)
 - ~~Localization~~ — 10 languages available (EN, KO, ZH-CN, JA, ES, VI, HI, RU, FR, DE)
+- ~~Kotlin / Spring Boot~~ — Implemented with CQRS, BFF, and multi-module monorepo support
 
 ## How to Contribute
 
@@ -27,11 +28,15 @@ Thank you for your interest in contributing! Here's how you can help.
 
 ## Adding a New Stack Template
 
+See `kotlin-spring/` as a reference implementation — it shows how to add CQRS/multi-module awareness on top of the standard 3-pass structure.
+
 1. Create a new directory under `pass-prompts/templates/your-stack/`
 2. Add `pass1.md`, `pass2.md`, `pass3.md` following the existing template structure
-3. Update `selectTemplates()` in `plan-installer/index.js`
+3. Update `detectStack()` in `plan-installer/index.js` to detect the new language/framework
 4. Update `scanStructure()` to detect the new stack's domains
-5. Update `README.md` Supported Stacks table
+5. Update `selectTemplates()` in `plan-installer/index.js` to route to the new template
+6. Update `README.md` Supported Stacks table
+7. Add FAQ and Troubleshooting entries for the new stack
 
 ## Code Style
 

package/README.de.md

@@ -8,7 +8,7 @@ npx claudeos-core init
 
 ClaudeOS-Core liest Ihre Codebasis, extrahiert jedes Muster und generiert einen vollständigen Satz von Standards, Rules, Skills und Guides, die auf _Ihr_ Projekt zugeschnitten sind. Danach, wenn Sie Claude Code sagen „Erstelle ein CRUD für Bestellungen", erzeugt es Code, der exakt Ihren bestehenden Mustern entspricht.
 
-[🇺🇸 English](./README.md) · [🇨🇳 中文](./README.zh-CN.md) · [🇯🇵 日本語](./README.ja.md) · [🇪🇸 Español](./README.es.md) · [🇻🇳 Tiếng Việt](./README.vi.md) · [🇮🇳 हिन्दी](./README.hi.md) · [🇷🇺 Русский](./README.ru.md) · [🇫🇷 Français](./README.fr.md) · [🇰🇷 한국어](./README.ko.md)
+[🇺🇸 English](./README.md) · [🇰🇷 한국어](./README.ko.md) · [🇨🇳 中文](./README.zh-CN.md) · [🇯🇵 日本語](./README.ja.md) · [🇪🇸 Español](./README.es.md) · [🇻🇳 Tiếng Việt](./README.vi.md) · [🇮🇳 हिन्दी](./README.hi.md) · [🇷🇺 Русский](./README.ru.md) · [🇫🇷 Français](./README.fr.md)
 
 ---
 
@@ -22,7 +22,7 @@ ClaudeOS-Core automatisiert den gesamten Prozess:
 
 1. **Scannt** Ihr Projekt — erkennt automatisch Stack, Domänen, ORM, Datenbank, Paketmanager
 2. **Analysiert** Ihren Quellcode tiefgehend — Controller-Muster, Service-Schichten, Namenskonventionen, Fehlerbehandlung, Sicherheit, Tests und 50+ Kategorien
-3. **Generiert** ein vollständiges Dokumentationsökosystem — `CLAUDE.md`, Standards (15–17 Dateien), Rules, Skills, Guides (9 Dateien), Master Plans, DB-Dokumentation und MCP-Leitfaden
+3. **Generiert** ein vollständiges Dokumentationsökosystem — `CLAUDE.md`, Standards (15–19 Dateien), Rules, Skills, Guides (9 Dateien), Master Plans, DB-Dokumentation und MCP-Leitfaden
 4. **Validiert** alles — 6 integrierte Verifizierungstools gewährleisten Konsistenz
 
 Gesamtzeit: **5–18 Minuten**, abhängig von der Projektgröße. Null manuelle Konfiguration.
@@ -34,12 +34,13 @@ Gesamtzeit: **5–18 Minuten**, abhängig von der Projektgröße. Null manuelle
 | Stack | Erkennung | Analysetiefe |
 |---|---|---|
 | **Java / Spring Boot** | `build.gradle`, `pom.xml`, 5 Paketmuster | 10 Kategorien, 59 Unterpunkte |
+| **Kotlin / Spring Boot** | `build.gradle.kts`, kotlin plugin, `settings.gradle.kts`, CQRS/BFF auto-detect | 12 Kategorien, 95 Unterpunkte |
 | **Node.js / Express / NestJS** | `package.json` | 9 Kategorien, 57 Unterpunkte |
 | **Next.js / React / Vue** | `package.json`, `next.config.*`, FSD-Unterstützung | 9 Kategorien, 55 Unterpunkte |
 | **Python / Django** | `requirements.txt`, `pyproject.toml` | 10 Kategorien, 55 Unterpunkte |
 | **Python / FastAPI** | `requirements.txt`, `pyproject.toml` | 10 Kategorien, 58 Unterpunkte |
 
-Automatisch erkannt: Sprache und Version, Framework und Version, ORM (MyBatis, JPA, Prisma, TypeORM, SQLAlchemy usw.), Datenbank (PostgreSQL, MySQL, Oracle, MongoDB, SQLite), Paketmanager (Gradle, Maven, npm, yarn, pnpm, pip, poetry).
+Automatisch erkannt: Sprache und Version, Framework und Version, ORM (MyBatis, JPA, Exposed, Prisma, TypeORM, SQLAlchemy usw.), Datenbank (PostgreSQL, MySQL, Oracle, MongoDB, SQLite), Paketmanager (Gradle, Maven, npm, yarn, pnpm, pip, poetry), Architektur (CQRS, BFF — aus Modulnamen erkannt), Multi-Modul-Struktur (aus settings.gradle).
 
 **Sie müssen nichts angeben. Alles wird automatisch erkannt.**
 
@@ -56,6 +57,21 @@ Automatisch erkannt: Sprache und Version, Framework und Version, ORM (MyBatis, J
 
 Domains nur mit Services (ohne Controller) werden ebenfalls erkannt. Übersprungen: `common`, `config`, `util`, `front`, `admin`, `v1`, `v2` usw.
 
+
+### Kotlin Multi-Modul Domain-Erkennung
+
+Für Kotlin-Projekte mit Gradle-Multi-Modul-Struktur (z.B. CQRS-Monorepo):
+
+| Schritt | Aktion | Beispiel |
+|---|---|---|
+| 1 | `settings.gradle.kts` nach `include()` scannen | 14 Module gefunden |
+| 2 | Modultyp aus Name erkennen | `reservation-command-server` → Typ: `command` |
+| 3 | Domain aus Modulname extrahieren | `reservation-command-server` → Domain: `reservation` |
+| 4 | Gleiche Domain über Module gruppieren | `reservation-command-server` + `common-query-server` → 1 Domain |
+| 5 | Architektur erkennen | Hat `command` + `query` Module → CQRS |
+
+Unterstützte Modultypen: `command`, `query`, `bff`, `integration`, `standalone`, `library`. Gemeinsame Bibliotheken (`shared-lib`, `integration-lib`) werden als spezielle Domains erkannt.
+
 ### Frontend-Domain-Erkennung
 
 - **App Router**: `app/{domain}/page.tsx` (Next.js)
@@ -78,16 +94,138 @@ Domains nur mit Services (ohne Controller) werden ebenfalls erkannt. Übersprung
 ```bash
 cd /your/project/root
 
-# Option A: npx (empfohlen)
+# Option A: npx (empfohlen — keine Installation nötig)
+npx claudeos-core init
+
+# Option B: globale Installation
+npm install -g claudeos-core
+claudeos-core init
+
+# Option C: Projekt devDependency
+npm install --save-dev claudeos-core
 npx claudeos-core init
 
-# Option B: git clone (für Entwicklung/Beiträge)
+# Option D: git clone (für Entwicklung/Beiträge)
 git clone https://github.com/claudeos-core/claudeos-core.git claudeos-core-tools
 bash claudeos-core-tools/bootstrap.sh
 ```
 
 Das war's. Nach 5–18 Minuten ist die gesamte Dokumentation generiert und einsatzbereit.
 
+### Manuelle Schritt-für-Schritt-Installation
+
+Wenn Sie volle Kontrolle über jede Phase wünschen — oder wenn die automatisierte Pipeline bei einem Schritt fehlschlägt — können Sie jede Stufe manuell ausführen. Dies ist auch nützlich, um die interne Funktionsweise von ClaudeOS-Core zu verstehen.
+
+#### Step 1: Klonen und Abhängigkeiten installieren
+
+```bash
+cd /your/project/root
+
+git clone https://github.com/claudeos-core/claudeos-core.git claudeos-core-tools
+cd claudeos-core-tools && npm install && cd ..
+```
+
+#### Step 2: Verzeichnisstruktur erstellen
+
+```bash
+# Rules
+mkdir -p .claude/rules/{00.core,10.backend,20.frontend,30.security-db,40.infra,50.sync}
+
+# Standards
+mkdir -p claudeos-core/standard/{00.core,10.backend-api,20.frontend-ui,30.security-db,40.infra,50.verification,90.optional}
+
+# Skills
+mkdir -p claudeos-core/skills/{00.shared,10.backend-crud/scaffold-crud-feature,20.frontend-page/scaffold-page-feature,50.testing,90.experimental}
+
+# Guide, Plan, Database, MCP, Generated
+mkdir -p claudeos-core/guide/{01.onboarding,02.usage,03.troubleshooting,04.architecture}
+mkdir -p claudeos-core/{plan,database,mcp-guide,generated}
+```
+
+#### Step 3: plan-installer ausführen (Projektanalyse)
+
+Scannt Ihr Projekt, erkennt den Stack, findet Domains, teilt sie in Gruppen auf und generiert Prompts.
+
+```bash
+node claudeos-core-tools/plan-installer/index.js
+```
+
+**Ausgabe (`claudeos-core/generated/`):**
+- `project-analysis.json` — erkannter Stack, Domains, Frontend-Info
+- `domain-groups.json` — Domain-Gruppen für Pass 1
+- `pass1-backend-prompt.md` / `pass1-frontend-prompt.md` — Analyse-Prompts
+- `pass2-prompt.md` — Merge-Prompt
+- `pass3-prompt.md` — Generierungs-Prompt
+
+Sie können diese Dateien inspizieren, um die Erkennungsgenauigkeit zu überprüfen, bevor Sie fortfahren.
+
+#### Step 4: Pass 1 — Tiefgehende Code-Analyse pro Domain-Gruppe
+
+Führen Sie Pass 1 für jede Domain-Gruppe aus. Prüfen Sie `domain-groups.json` für die Anzahl der Gruppen.
+
+```bash
+# Check groups
+cat claudeos-core/generated/domain-groups.json | node -e "
+  const g = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+  g.groups.forEach((g,i) => console.log('Group '+(i+1)+': ['+g.domains.join(', ')+'] ('+g.type+', ~'+g.estimatedFiles+' files)'));
+"
+
+# Run Pass 1 for group 1:
+cat claudeos-core/generated/pass1-backend-prompt.md \
+  | sed "s/{{DOMAIN_GROUP}}/user, order, product/g" \
+  | sed "s/{{PASS_NUM}}/1/g" \
+  | claude -p --dangerously-skip-permissions
+
+# For frontend groups, use pass1-frontend-prompt.md instead
+```
+
+**Prüfen:** `ls claudeos-core/generated/pass1-*.json` sollte pro Gruppe eine JSON zeigen.
+
+#### Step 5: Pass 2 — Analyseergebnisse zusammenführen
+
+```bash
+cat claudeos-core/generated/pass2-prompt.md \
+  | claude -p --dangerously-skip-permissions
+```
+
+**Prüfen:** `claudeos-core/generated/pass2-merged.json` sollte existieren mit 9+ Top-Level-Schlüsseln.
+
+#### Step 6: Pass 3 — Gesamte Dokumentation generieren
+
+```bash
+cat claudeos-core/generated/pass3-prompt.md \
+  | claude -p --dangerously-skip-permissions
+```
+
+**Prüfen:** `CLAUDE.md` sollte im Projekt-Root existieren.
+
+#### Step 7: Verifizierungstools ausführen
+
+```bash
+# Metadaten generieren (vor anderen Prüfungen erforderlich)
+node claudeos-core-tools/manifest-generator/index.js
+
+# Alle Prüfungen ausführen
+node claudeos-core-tools/health-checker/index.js
+
+# Oder einzelne Prüfungen ausführen:
+node claudeos-core-tools/import-linter/index.js        # @import validation
+node claudeos-core-tools/plan-validator/index.js --check # Plan ↔ disk
+node claudeos-core-tools/sync-checker/index.js          # Sync status
+node claudeos-core-tools/content-validator/index.js     # Content quality
+node claudeos-core-tools/pass-json-validator/index.js   # JSON format
+```
+
+#### Step 8: Ergebnisse überprüfen
+
+```bash
+find .claude claudeos-core -type f | grep -v node_modules | wc -l
+head -30 CLAUDE.md
+ls .claude/rules/*/
+```
+
+> **Tipp:** Wenn ein Schritt fehlschlägt, können Sie nur diesen Schritt erneut ausführen. Pass 1/2-Ergebnisse werden gecacht — wenn `pass1-N.json` oder `pass2-merged.json` bereits existiert, überspringt die automatisierte Pipeline sie. Löschen Sie die Datei, um eine erneute Ausführung zu erzwingen.
+
 ### Nutzung starten
 
 ```
@@ -129,7 +267,7 @@ npx claudeos-core init
 
 ### Warum 3 Passes?
 
-**Pass 1** ist der einzige Pass, der Ihren Quellcode liest. Er wählt repräsentative Dateien pro Domäne aus und extrahiert Muster über 55–59 Analysekategorien (pro Stack). Bei großen Projekten wird Pass 1 mehrfach ausgeführt — einmal pro Domänengruppe. In Multi-Stack-Projekten (z.B. Java-Backend + React-Frontend) verwenden Backend und Frontend **unterschiedliche Analyse-Prompts**, die auf jeden Stack zugeschnitten sind.
+**Pass 1** ist der einzige Pass, der Ihren Quellcode liest. Er wählt repräsentative Dateien pro Domäne aus und extrahiert Muster über 55–95 Analysekategorien (pro Stack). Bei großen Projekten wird Pass 1 mehrfach ausgeführt — einmal pro Domänengruppe. In Multi-Stack-Projekten (z.B. Java-Backend + React-Frontend) verwenden Backend und Frontend **unterschiedliche Analyse-Prompts**, die auf jeden Stack zugeschnitten sind.
 
 **Pass 2** führt alle Pass-1-Ergebnisse zu einer einheitlichen Analyse zusammen: gemeinsame Muster (100% geteilt), Mehrheitsmuster (50%+ geteilt), domänenspezifische Muster, Anti-Muster nach Schweregrad und Querschnittsthemen (Benennung, Sicherheit, DB, Tests, Logging, Performance).
 
@@ -155,7 +293,7 @@ your-project/
 │
 ├── claudeos-core/                     ← Hauptausgabeverzeichnis
 │   ├── generated/                     ← Analyse-JSON + dynamische Prompts
-│   ├── standard/                      ← Code-Standards (15-17 Dateien)
+│   ├── standard/                      ← Code-Standards (15-19 Dateien)
 │   ├── skills/                        ← CRUD-Scaffolding-Skills
 │   ├── guide/                         ← Onboarding, FAQ, Fehlerbehebung (9 Dateien)
 │   ├── plan/                          ← Master Plans (Backup/Wiederherstellung)
@@ -249,9 +387,10 @@ npx claudeos-core restore
 
 | | ClaudeOS-Core | SuperClaude | Manuelle CLAUDE.md | Generische Skills |
 |---|---|---|---|---|
-| **Liest Ihren Code** | ✅ Tiefenanalyse (55–59 Kategorien) | ❌ Verhaltensinjektion | ❌ Manuelles Schreiben | ❌ Vorgefertigte Vorlagen |
+| **Liest Ihren Code** | ✅ Tiefenanalyse (55–95 Kategorien) | ❌ Verhaltensinjektion | ❌ Manuelles Schreiben | ❌ Vorgefertigte Vorlagen |
 | **Projektspezifische Ausgabe** | ✅ Jede Datei spiegelt Ihre Muster wider | ❌ Generische Befehle | Teilweise | ❌ Einheitsgröße |
 | **Multi-Stack** | ✅ Auto-Erkennung + separate Analyse | ❌ Stack-agnostisch | Manuell | Variiert |
+| **Kotlin + CQRS/BFF** | ✅ Multi-Modul, Command/Query-Trennung | ❌ | ❌ | ❌ |
 | **Selbstverifizierung** | ✅ 6 Validierungstools | ❌ | ❌ | ❌ |
 | **Backup / Wiederherstellung** | ✅ Master Plan System | ❌ | ❌ | ❌ |
 | **Einrichtungszeit** | ~5–18 Min (automatisch) | ~5 Min (manuelle Konfig) | Stunden–Tage | ~5 Min |
@@ -275,6 +414,15 @@ Vollständig unterstützt. ClaudeOS-Core erkennt automatisch beide Stacks, taggt
 **F: Was passiert bei erneutem Ausführen?**
 Pass 1/2 werden übersprungen, wenn ihr JSON bereits existiert. Pass 3 wird immer erneut ausgeführt. Frühere Versionen können aus Master Plans wiederhergestellt werden.
 
+**F: Wird Kotlin unterstützt?**
+Ja. ClaudeOS-Core erkennt Kotlin automatisch aus `build.gradle.kts` oder dem Kotlin-Plugin in `build.gradle`. Es verwendet ein dediziertes `kotlin-spring`-Template mit Kotlin-spezifischer Analyse (Data Classes, Sealed Classes, Coroutines, Extension Functions, MockK usw.).
+
+**F: Was ist mit CQRS / BFF-Architektur?**
+Vollständig unterstützt für Kotlin-Multi-Modul-Projekte. ClaudeOS-Core liest `settings.gradle.kts`, erkennt Modultypen (command, query, bff, integration) aus den Modulnamen und gruppiert dieselbe Domäne über Command/Query-Module. Die generierten Standards enthalten separate Regeln für Command-Controller vs. Query-Controller, BFF/Feign-Patterns und Inter-Modul-Kommunikationskonventionen.
+
+**F: Was ist mit Gradle-Multi-Modul-Monorepos?**
+ClaudeOS-Core scannt alle Submodule (`**/src/main/kotlin/**/*.kt`) unabhängig von der Verschachtelungstiefe. Modultypen werden aus Namenskonventionen abgeleitet (z.B. `reservation-command-server` → Domäne: `reservation`, Typ: `command`). Gemeinsame Bibliotheken (`shared-lib`, `integration-lib`) werden ebenfalls erkannt.
+
 ---
 
 ## Template-Struktur
@@ -283,6 +431,7 @@ Pass 1/2 werden übersprungen, wenn ihr JSON bereits existiert. Pass 3 wird imme
 pass-prompts/templates/
 ├── common/                  # Gemeinsamer Header/Footer
 ├── java-spring/             # Java / Spring Boot
+├── kotlin-spring/           # Kotlin / Spring Boot (CQRS, BFF, multi-module)
 ├── node-express/            # Node.js / Express / NestJS
 ├── node-nextjs/             # Next.js / React / Vue
 ├── python-django/           # Python / Django (DRF)
@@ -334,7 +483,13 @@ my-monorepo/                    ← Nicht hier ausführen (Root hat keine Framew
 
 **"npm install failed"** — Node.js-Version könnte zu niedrig sein. v18+ erforderlich.
 
-**"0 domains detected"** — Ihre Projektstruktur könnte nicht standardmäßig sein. Siehe die Erkennungsmuster in der [koreanischen Dokumentation](./README.ko.md#-문제-해결--troubleshooting) für Ihren Stack.
+**"0 domains detected"** — Ihre Projektstruktur könnte nicht standardmäßig sein. Siehe die Erkennungsmuster in der [koreanischen Dokumentation](./README.ko.md#트러블슈팅) für Ihren Stack.
+
+**„0 Domains erkannt" bei Kotlin-Projekt** — Stellen Sie sicher, dass `build.gradle.kts` (oder `build.gradle` mit Kotlin-Plugin) im Projektstamm existiert und Quelldateien unter `**/src/main/kotlin/` liegen. Bei Multi-Modul-Projekten muss `settings.gradle.kts` `include()`-Anweisungen enthalten. Einzelmodul-Kotlin-Projekte (ohne `settings.gradle`) werden ebenfalls unterstützt — Domänen werden aus der Paket-/Klassenstruktur unter `src/main/kotlin/` extrahiert.
+
+**„Sprache als java statt kotlin erkannt"** — ClaudeOS-Core prüft zuerst die Root-`build.gradle(.kts)`, dann Submodul-Build-Dateien. Stellen Sie sicher, dass mindestens eine `kotlin("jvm")` oder `org.jetbrains.kotlin` enthält.
+
+**„CQRS nicht erkannt"** — Die Architekturerkennung basiert auf den Schlüsselwörtern `command` und `query` in Modulnamen. Wenn Ihre Module andere Bezeichnungen verwenden, können Sie die generierten Prompts nach dem plan-installer manuell anpassen.
 
 ---
 

package/README.es.md

@@ -8,7 +8,7 @@ npx claudeos-core init
 
 ClaudeOS-Core lee tu código fuente, extrae cada patrón que encuentra y genera un conjunto completo de Standards, Rules, Skills y Guides adaptados a _tu_ proyecto. Después, cuando le digas a Claude Code "Crea un CRUD para pedidos", generará código que coincide exactamente con tus patrones existentes.
 
-[🇺🇸 English](./README.md) · [🇨🇳 中文](./README.zh-CN.md) · [🇯🇵 日本語](./README.ja.md) · [🇻🇳 Tiếng Việt](./README.vi.md) · [🇮🇳 हिन्दी](./README.hi.md) · [🇷🇺 Русский](./README.ru.md) · [🇫🇷 Français](./README.fr.md) · [🇩🇪 Deutsch](./README.de.md) · [🇰🇷 한국어](./README.ko.md)
+[🇺🇸 English](./README.md) · [🇰🇷 한국어](./README.ko.md) · [🇨🇳 中文](./README.zh-CN.md) · [🇯🇵 日本語](./README.ja.md) · [🇻🇳 Tiếng Việt](./README.vi.md) · [🇮🇳 हिन्दी](./README.hi.md) · [🇷🇺 Русский](./README.ru.md) · [🇫🇷 Français](./README.fr.md) · [🇩🇪 Deutsch](./README.de.md)
 
 ---
 
@@ -22,7 +22,7 @@ ClaudeOS-Core automatiza todo el proceso:
 
 1. **Escanea** tu proyecto — detecta automáticamente stack, dominios, ORM, base de datos y gestor de paquetes
 2. **Analiza** tu código fuente en profundidad — patrones de controladores, capas de servicio, convenciones de nombrado, manejo de errores, seguridad, testing y más de 50 categorías
-3. **Genera** un ecosistema documental completo — `CLAUDE.md`, Standards (15–17 archivos), Rules, Skills, Guides (9 archivos), Master Plans, documentación de BD y guía MCP
+3. **Genera** un ecosistema documental completo — `CLAUDE.md`, Standards (15–19 archivos), Rules, Skills, Guides (9 archivos), Master Plans, documentación de BD y guía MCP
 4. **Valida** todo — 6 herramientas de verificación integradas garantizan la consistencia
 
 Tiempo total: **5–18 minutos**, según el tamaño del proyecto. Cero configuración manual.
@@ -34,12 +34,13 @@ Tiempo total: **5–18 minutos**, según el tamaño del proyecto. Cero configura
 | Stack | Detección | Profundidad de Análisis |
 |---|---|---|
 | **Java / Spring Boot** | `build.gradle`, `pom.xml`, 5 patrones de paquete | 10 categorías, 59 sub-ítems |
+| **Kotlin / Spring Boot** | `build.gradle.kts`, kotlin plugin, `settings.gradle.kts`, CQRS/BFF auto-detect | 12 categorías, 95 sub-ítems |
 | **Node.js / Express / NestJS** | `package.json` | 9 categorías, 57 sub-ítems |
 | **Next.js / React / Vue** | `package.json`, `next.config.*`, soporte FSD | 9 categorías, 55 sub-ítems |
 | **Python / Django** | `requirements.txt`, `pyproject.toml` | 10 categorías, 55 sub-ítems |
 | **Python / FastAPI** | `requirements.txt`, `pyproject.toml` | 10 categorías, 58 sub-ítems |
 
-Detección automática: lenguaje y versión, framework y versión, ORM (MyBatis, JPA, Prisma, TypeORM, SQLAlchemy, etc.), base de datos (PostgreSQL, MySQL, Oracle, MongoDB, SQLite), gestor de paquetes (Gradle, Maven, npm, yarn, pnpm, pip, poetry).
+Detección automática: lenguaje y versión, framework y versión, ORM (MyBatis, JPA, Exposed, Prisma, TypeORM, SQLAlchemy, etc.), base de datos (PostgreSQL, MySQL, Oracle, MongoDB, SQLite), gestor de paquetes (Gradle, Maven, npm, yarn, pnpm, pip, poetry), arquitectura (CQRS, BFF — detectado de nombres de módulos), estructura multi-módulo (desde settings.gradle).
 
 **No necesitas especificar nada. Todo se detecta automáticamente.**
 
@@ -56,6 +57,21 @@ Detección automática: lenguaje y versión, framework y versión, ORM (MyBatis,
 
 Los dominios solo con servicios (sin controladores) también se detectan. Se omiten: `common`, `config`, `util`, `front`, `admin`, `v1`, `v2`, etc.
 
+
+### Detección de Dominios Kotlin Multi-Módulo
+
+Para proyectos Kotlin con estructura Gradle multi-módulo (ej: monorepo CQRS):
+
+| Paso | Acción | Ejemplo |
+|---|---|---|
+| 1 | Escanear `settings.gradle.kts` buscando `include()` | Encuentra 14 módulos |
+| 2 | Detectar tipo de módulo por nombre | `reservation-command-server` → tipo: `command` |
+| 3 | Extraer dominio del nombre del módulo | `reservation-command-server` → dominio: `reservation` |
+| 4 | Agrupar mismo dominio entre módulos | `reservation-command-server` + `common-query-server` → 1 dominio |
+| 5 | Detectar arquitectura | Tiene módulos `command` + `query` → CQRS |
+
+Tipos de módulo soportados: `command`, `query`, `bff`, `integration`, `standalone`, `library`. Las bibliotecas compartidas (`shared-lib`, `integration-lib`) se detectan como dominios especiales.
+
 ### Detección de Dominios Frontend
 
 - **App Router**: `app/{domain}/page.tsx` (Next.js)
@@ -78,16 +94,138 @@ Los dominios solo con servicios (sin controladores) también se detectan. Se omi
 ```bash
 cd /your/project/root
 
-# Opción A: npx (recomendado)
+# Opción A: npx (recomendado — sin instalación)
+npx claudeos-core init
+
+# Opción B: instalación global
+npm install -g claudeos-core
+claudeos-core init
+
+# Opción C: devDependency del proyecto
+npm install --save-dev claudeos-core
 npx claudeos-core init
 
-# Opción B: git clone (para desarrollo/contribución)
+# Opción D: git clone (para desarrollo/contribución)
 git clone https://github.com/claudeos-core/claudeos-core.git claudeos-core-tools
 bash claudeos-core-tools/bootstrap.sh
 ```
 
 Eso es todo. Después de 5–18 minutos, toda la documentación estará generada y lista para usar.
 
+### Instalación Manual Paso a Paso
+
+Si deseas control total sobre cada fase, o si el pipeline automatizado falla en algún paso, puedes ejecutar cada etapa manualmente. También es útil para entender cómo funciona ClaudeOS-Core internamente.
+
+#### Step 1: Clonar e instalar dependencias
+
+```bash
+cd /your/project/root
+
+git clone https://github.com/claudeos-core/claudeos-core.git claudeos-core-tools
+cd claudeos-core-tools && npm install && cd ..
+```
+
+#### Step 2: Crear estructura de directorios
+
+```bash
+# Rules
+mkdir -p .claude/rules/{00.core,10.backend,20.frontend,30.security-db,40.infra,50.sync}
+
+# Standards
+mkdir -p claudeos-core/standard/{00.core,10.backend-api,20.frontend-ui,30.security-db,40.infra,50.verification,90.optional}
+
+# Skills
+mkdir -p claudeos-core/skills/{00.shared,10.backend-crud/scaffold-crud-feature,20.frontend-page/scaffold-page-feature,50.testing,90.experimental}
+
+# Guide, Plan, Database, MCP, Generated
+mkdir -p claudeos-core/guide/{01.onboarding,02.usage,03.troubleshooting,04.architecture}
+mkdir -p claudeos-core/{plan,database,mcp-guide,generated}
+```
+
+#### Step 3: Ejecutar plan-installer (análisis del proyecto)
+
+Escanea tu proyecto, detecta el stack, encuentra dominios, los divide en grupos y genera prompts.
+
+```bash
+node claudeos-core-tools/plan-installer/index.js
+```
+
+**Salida (`claudeos-core/generated/`):**
+- `project-analysis.json` — stack detectado, dominios, info de frontend
+- `domain-groups.json` — grupos de dominios para Pass 1
+- `pass1-backend-prompt.md` / `pass1-frontend-prompt.md` — prompts de análisis
+- `pass2-prompt.md` — prompt de fusión
+- `pass3-prompt.md` — prompt de generación
+
+Puedes inspeccionar estos archivos para verificar la precisión de la detección antes de continuar.
+
+#### Step 4: Pass 1 — Análisis profundo de código por grupo de dominio
+
+Ejecuta Pass 1 para cada grupo de dominio. Revisa `domain-groups.json` para el número de grupos.
+
+```bash
+# Check groups
+cat claudeos-core/generated/domain-groups.json | node -e "
+  const g = JSON.parse(require('fs').readFileSync('/dev/stdin','utf-8'));
+  g.groups.forEach((g,i) => console.log('Group '+(i+1)+': ['+g.domains.join(', ')+'] ('+g.type+', ~'+g.estimatedFiles+' files)'));
+"
+
+# Run Pass 1 for group 1:
+cat claudeos-core/generated/pass1-backend-prompt.md \
+  | sed "s/{{DOMAIN_GROUP}}/user, order, product/g" \
+  | sed "s/{{PASS_NUM}}/1/g" \
+  | claude -p --dangerously-skip-permissions
+
+# For frontend groups, use pass1-frontend-prompt.md instead
+```
+
+**Verificar:** `ls claudeos-core/generated/pass1-*.json` debe mostrar un JSON por grupo.
+
+#### Step 5: Pass 2 — Fusionar resultados de análisis
+
+```bash
+cat claudeos-core/generated/pass2-prompt.md \
+  | claude -p --dangerously-skip-permissions
+```
+
+**Verificar:** `claudeos-core/generated/pass2-merged.json` debe existir con 9+ claves de nivel superior.
+
+#### Step 6: Pass 3 — Generar toda la documentación
+
+```bash
+cat claudeos-core/generated/pass3-prompt.md \
+  | claude -p --dangerously-skip-permissions
+```
+
+**Verificar:** `CLAUDE.md` debe existir en la raíz del proyecto.
+
+#### Step 7: Ejecutar herramientas de verificación
+
+```bash
+# Generar metadatos (requerido antes de otras verificaciones)
+node claudeos-core-tools/manifest-generator/index.js
+
+# Ejecutar todas las verificaciones
+node claudeos-core-tools/health-checker/index.js
+
+# O ejecutar verificaciones individuales:
+node claudeos-core-tools/import-linter/index.js        # @import validation
+node claudeos-core-tools/plan-validator/index.js --check # Plan ↔ disk
+node claudeos-core-tools/sync-checker/index.js          # Sync status
+node claudeos-core-tools/content-validator/index.js     # Content quality
+node claudeos-core-tools/pass-json-validator/index.js   # JSON format
+```
+
+#### Step 8: Verificar los resultados
+
+```bash
+find .claude claudeos-core -type f | grep -v node_modules | wc -l
+head -30 CLAUDE.md
+ls .claude/rules/*/
+```
+
+> **Consejo:** Si un paso falla, puedes volver a ejecutar solo ese paso. Los resultados de Pass 1/2 se cachean — si `pass1-N.json` o `pass2-merged.json` ya existen, el pipeline automatizado los omite. Elimina el archivo para forzar la re-ejecución.
+
 ### Empieza a Usar
 
 ```
@@ -129,7 +267,7 @@ npx claudeos-core init
 
 ### ¿Por Qué 3 Pasadas?
 
-**Pass 1** es la única pasada que lee tu código fuente. Selecciona archivos representativos por dominio y extrae patrones en 55–59 categorías de análisis (por stack). Para proyectos grandes, Pass 1 se ejecuta múltiples veces — una por grupo de dominios. En proyectos multi-stack (ej: backend Java + frontend React), backend y frontend usan **prompts de análisis diferentes** adaptados a cada stack.
+**Pass 1** es la única pasada que lee tu código fuente. Selecciona archivos representativos por dominio y extrae patrones en 55–95 categorías de análisis (por stack). Para proyectos grandes, Pass 1 se ejecuta múltiples veces — una por grupo de dominios. En proyectos multi-stack (ej: backend Java + frontend React), backend y frontend usan **prompts de análisis diferentes** adaptados a cada stack.
 
 **Pass 2** fusiona todos los resultados de Pass 1 en un análisis unificado: patrones comunes (100% compartidos), patrones mayoritarios (50%+ compartidos), patrones específicos de dominio, anti-patrones por severidad y preocupaciones transversales (nombrado, seguridad, BD, testing, logging, rendimiento).
 
@@ -155,7 +293,7 @@ your-project/
 │
 ├── claudeos-core/                     ← Directorio principal de salida
 │   ├── generated/                     ← JSON de análisis + prompts dinámicos
-│   ├── standard/                      ← Estándares de código (15-17 archivos)
+│   ├── standard/                      ← Estándares de código (15-19 archivos)
 │   ├── skills/                        ← Skills de scaffolding CRUD
 │   ├── guide/                         ← Onboarding, FAQ, troubleshooting (9 archivos)
 │   ├── plan/                          ← Master Plans (backup/restauración)
@@ -249,9 +387,10 @@ npx claudeos-core restore
 
 | | ClaudeOS-Core | SuperClaude | CLAUDE.md Manual | Skills Genéricos |
 |---|---|---|---|---|
-| **Lee tu código** | ✅ Análisis profundo (55–59 categorías) | ❌ Inyección de comportamiento | ❌ Escritura manual | ❌ Plantillas predefinidas |
+| **Lee tu código** | ✅ Análisis profundo (55–95 categorías) | ❌ Inyección de comportamiento | ❌ Escritura manual | ❌ Plantillas predefinidas |
 | **Salida específica del proyecto** | ✅ Cada archivo refleja tus patrones | ❌ Comandos genéricos | Parcial | ❌ Talla única |
 | **Multi-stack** | ✅ Auto-detección + análisis separado | ❌ Agnóstico al stack | Manual | Variable |
+| **Kotlin + CQRS/BFF** | ✅ Multi-module, Command/Query split | ❌ | ❌ | ❌ |
 | **Auto-verificación** | ✅ 6 herramientas de validación | ❌ | ❌ | ❌ |
 | **Backup / Restauración** | ✅ Sistema Master Plan | ❌ | ❌ | ❌ |
 | **Tiempo de configuración** | ~5–18min (automático) | ~5min (config manual) | Horas–Días | ~5min |
@@ -275,6 +414,15 @@ Totalmente soportado. ClaudeOS-Core auto-detecta ambos stacks, etiqueta dominios
 **P: ¿Qué pasa al re-ejecutar?**
 Pass 1/2 se omiten si su JSON ya existe. Pass 3 siempre se re-ejecuta. Las versiones anteriores pueden restaurarse desde los Master Plans.
 
+**P: ¿Soporta Kotlin?**
+Sí. ClaudeOS-Core detecta automáticamente Kotlin desde `build.gradle.kts` o el plugin kotlin en `build.gradle`. Utiliza una plantilla dedicada `kotlin-spring` con análisis específico de Kotlin (data classes, sealed classes, coroutines, extension functions, MockK, etc.).
+
+**P: ¿Qué hay de la arquitectura CQRS / BFF?**
+Totalmente soportado para proyectos multi-módulo de Kotlin. ClaudeOS-Core lee `settings.gradle.kts`, detecta tipos de módulos (command, query, bff, integration) de los nombres, y agrupa el mismo dominio entre módulos Command/Query. Los estándares generados incluyen reglas separadas para command controllers vs query controllers, patrones BFF/Feign y convenciones de comunicación entre módulos.
+
+**P: ¿Qué hay de los monorepos multi-módulo de Gradle?**
+ClaudeOS-Core escanea todos los submódulos (`**/src/main/kotlin/**/*.kt`) sin importar la profundidad de anidamiento. Los tipos de módulos se infieren de las convenciones de nombres (ej: `reservation-command-server` → dominio: `reservation`, tipo: `command`). Las bibliotecas compartidas (`shared-lib`, `integration-lib`) también se detectan.
+
 ---
 
 ## Estructura de Plantillas
@@ -283,6 +431,7 @@ Pass 1/2 se omiten si su JSON ya existe. Pass 3 siempre se re-ejecuta. Las versi
 pass-prompts/templates/
 ├── common/                  # Encabezado/pie compartido
 ├── java-spring/             # Java / Spring Boot
+├── kotlin-spring/           # Kotlin / Spring Boot (CQRS, BFF, multi-module)
 ├── node-express/            # Node.js / Express / NestJS
 ├── node-nextjs/             # Next.js / React / Vue
 ├── python-django/           # Python / Django (DRF)
@@ -334,7 +483,13 @@ my-monorepo/                    ← No ejecutes aquí (la raíz no tiene deps de
 
 **"npm install failed"** — La versión de Node.js puede ser demasiado baja. Se requiere v18+.
 
-**"0 domains detected"** — La estructura de tu proyecto puede ser no estándar. Consulta los patrones de detección en la [documentación en coreano](./README.ko.md#-문제-해결--troubleshooting) para tu stack.
+**"0 domains detected"** — La estructura de tu proyecto puede ser no estándar. Consulta los patrones de detección en la [documentación en coreano](./README.ko.md#트러블슈팅) para tu stack.
+
+**"0 dominios detectados" en proyecto Kotlin** — Asegúrate de que `build.gradle.kts` (o `build.gradle` con plugin kotlin) exista en la raíz, y los archivos fuente estén bajo `**/src/main/kotlin/`. Para proyectos multi-módulo, `settings.gradle.kts` debe contener sentencias `include()`. Los proyectos Kotlin de módulo único (sin `settings.gradle`) también son compatibles — los dominios se extraen de la estructura de paquetes/clases bajo `src/main/kotlin/`.
+
+**"Lenguaje detectado como java en vez de kotlin"** — ClaudeOS-Core primero verifica el `build.gradle(.kts)` raíz, luego los archivos build de submódulos. Asegúrate de que al menos uno contenga `kotlin("jvm")` o `org.jetbrains.kotlin`.
+
+**"CQRS no detectado"** — La detección de arquitectura depende de que los nombres de módulos contengan las palabras `command` y `query`. Si tus módulos usan nombres diferentes, puedes ajustar manualmente los prompts generados.
 
 ---