claudeos-core 1.0.7 → 1.2.0

package/CHANGELOG.md

@@ -1,6 +1,89 @@
 # Changelog
 
-## [1.0.0] — 2025
+## [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):
+  - A: `controller/{domain}/` (layer-first)
+  - B: `{domain}/controller/` (domain-first)
+  - C: `controller/*.java` (flat, extract from class name)
+  - D: `{module}/{domain}/controller/` (module prefix, auto-upgrade on name conflict)
+  - E: `{domain}/adapter/in/web/` (DDD/hexagonal)
+- **Service-only domain detection**: Domains without controllers (e.g., `core/delivery/service/`) are now detected
+- **Frontend FSD support**: `features/*/`, `widgets/*/`, `entities/*/` (Feature-Sliced Design)
+- **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
+- **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)
+- **Skip filters**: API version paths (`v1`, `v2`), module prefixes (`front`, `admin`, `back`) excluded from domain detection
+
+### Fixed
+- `frontend` variable reference before initialization (RSC stats)
+- npm bin path warning (`npm pkg fix`)
+
+## [1.0.0] — 2025-12-01
 
 ### Added
 - 3-Pass pipeline: Deep analysis → Merge → Generate

package/CONTRIBUTING.md

@@ -5,9 +5,16 @@ Thank you for your interest in contributing! Here's how you can help.
 ## Areas Where Help Is Needed
 
 - **New stack templates** — Ruby/Rails, Go/Gin, PHP/Laravel, Rust/Axum
-- **Monorepo deep support** — Separate sub-project roots, workspace detection
+- **IDE integration** — VS Code extension, IntelliJ plugin
 - **Test coverage** — Unit tests for verification tools
-- **Localization** — README translations (Chinese, Japanese, Spanish, etc.)
+- **CI/CD templates** — GitHub Actions, GitLab CI integration examples
+- **Custom template authoring** — User-defined pass1/pass2/pass3 templates
+
+## What's Already Done (no longer needed)
+
+- ~~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
 
@@ -21,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.
@@ -33,16 +33,53 @@ Gesamtzeit: **5–18 Minuten**, abhängig von der Projektgröße. Null manuelle
 
 | Stack | Erkennung | Analysetiefe |
 |---|---|---|
-| **Java / Spring Boot** | `build.gradle`, `pom.xml` | 10 Kategorien, 59 Unterpunkte |
+| **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, react, vue) | 9 Kategorien, 55 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.**
 
+
+### Java-Domain-Erkennung (5 Muster mit Fallback)
+
+| Priorität | Muster | Struktur | Beispiel |
+|---|---|---|---|
+| A | Layer-first | `controller/{domain}/` | `controller/user/UserController.java` |
+| B | Domain-first | `{domain}/controller/` | `user/controller/UserController.java` |
+| D | Modul-Präfix | `{module}/{domain}/controller/` | `front/member/controller/MemberController.java` |
+| E | DDD/Hexagonal | `{domain}/adapter/in/web/` | `user/adapter/in/web/UserController.java` |
+| C | Flach | `controller/*.java` | `controller/UserController.java` → extrahiert `user` aus Klassenname |
+
+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)
+- **Pages Router**: `pages/{domain}/index.tsx`
+- **FSD (Feature-Sliced Design)**: `features/*/`, `widgets/*/`, `entities/*/`
+- **RSC/Client-Split**: Erkennt `client.tsx`-Muster, verfolgt Server/Client-Trennung
+- **Config-Fallback**: Erkennt Next.js/Vite/Nuxt aus Config-Dateien (Monorepo-Unterstützung)
+
 ---
 
 ## Schnellstart
@@ -57,16 +94,138 @@ Automatisch erkannt: Sprache und Version, Framework und Version, ORM (MyBatis, J
 ```bash
 cd /your/project/root
 
-# Option A: npx (empfohlen)
+# Option A: npx (empfohlen — keine Installation nötig)
 npx claudeos-core init
 
-# Option B: git clone (für Entwicklung/Beiträge)
+# 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 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
 
 ```
@@ -108,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).
 
@@ -134,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)
@@ -228,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 |
@@ -254,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
@@ -262,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)
@@ -313,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.
 
 ---