claudeos-core 1.3.1 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [1.4.0] — 2026-04-04
+
+### Fixed
+- **Arrow key compatibility** — Added application mode escape sequences (`\x1bOA`/`\x1bOB`) for terminals that use SS3 mode (Git Bash/mintty, tmux, screen); previously only normal mode (`\x1b[A`/`\x1b[B`) was handled
+- **`setRawMode` crash prevention** — Wrapped `setRawMode(true)` in try-catch; falls back to number input if raw mode is unsupported (e.g., some Windows terminal emulators)
+- **React/CRA/Vite/RN frontend domain detection** — Added Fallback C (`**/components/*/`) and Fallback D (deep `**/views/*/`, `**/screens/*/`, `**/containers/*/`, `**/pages/*/`, `**/routes/*/`, `**/modules/*/`, `**/domains/*/`) for pure React projects without Next.js App Router; previously only `{src/,}components/*/` (1-depth) was scanned, causing 0 domains for projects with deep component structures (e.g., `src/desktop/app/components/order/`)
+- **Vue `.vue` file detection** — Added `.vue` extension to all frontend domain scanning globs (primary, FSD, components, Fallback B/C/D); previously `.vue` was only included in statistics globs but not in domain detection, causing 0 domains for Vue/Nuxt projects
+- **`setRawMode` fallback UX** — Added "Generated files will be written in this language" description text to setRawMode fallback path (was missing, non-TTY and arrow-key paths had it)
+- **Fallback C/D glob performance** — Added `.git`, `vendor`, `__pycache__`, `coverage` to ignore list (prevents scanning non-source directories in large repos)
+- **Fallback D domain source tracking** — Domain entries now include `sources` field recording which directory pattern(s) matched (e.g., `["views", "routes"]`), preventing silent conflation
+- **`plan-validator` / `sync-checker` path traversal** — Changed `startsWith(ROOT + sep)` to also allow `=== ROOT` (fixes edge case where ROOT-level files like `CLAUDE.md` could be rejected on Windows)
+- **`content-validator` Kotlin code block check** — Core standard files (`00.core/02.`, `00.core/03.`) downgraded from warning to silent skip (may legitimately lack `\`\`\`kotlin` blocks in multi-stack projects)
+- **`manifest-generator` sync-map completeness** — Code-block format plan files (e.g., `21.sync-rules-master.md`) now included in `sync-map.json`; previously only `<file>` block format plans were extracted, causing sync-checker to report false "unregistered" entries
+
+### Changed
+- **Language selector hint** — Added `1-0 Jump` and `ESC Cancel` to the interactive selector hint line (`↑↓ Move  1-0 Jump  Enter Select  ESC Cancel`); users can now discover number key shortcuts without reading docs
+- **`bootstrap.sh` completion box** — Added `Output language:` line (was missing, cli.js had it); changed verify command from `node claudeos-core-tools/health-checker/index.js` to `npx claudeos-core health` (matches cli.js)
+- **All 10 READMEs** — Language selector example updated to match new hint text; description text changed from "arrow keys" to "arrow keys or number keys"
+- **`selectTemplates` pure frontend fix** — TypeScript/JavaScript/Python language-only fallback no longer assigns a backend template when `stack.framework` is absent; pure frontend projects (CRA, Vite, Vue CLI) now correctly get `backend: null` instead of `node-express`
+- **`stack-detector` NestJS priority** — NestJS checked before Express (NestJS is more specific; NestJS projects always include express as a dependency); both now use `!stack.framework` guard for order-independence
+- **`domain-grouper` dead code removal** — Removed unreachable `if (!templates.backend && templates.frontend)` block and orphaned "Dynamic prompt generation" comment
+- **`cli.js` `countFiles` resilience** — `realpathSync` wrapped in try-catch to handle Windows junction points that throw
+- **`bootstrap.sh` prerequisites** — Added `perl` to header comment prerequisites list
+
 ## [1.3.1] — 2026-04-03
 
 ### Changed

package/README.de.md

@@ -1,6 +1,6 @@
 # ClaudeOS-Core
 
-**Ein Befehl. Ihre gesamte Claude Code Dokumentation — automatisch aus Ihrem Quellcode generiert.**
+**Das einzige Tool, das zuerst Ihren Quellcode liest, Stack und Patterns mit deterministischer Analyse bestätigt und dann Claude Code Regeln generiert, die exakt auf Ihr Projekt zugeschnitten sind.**
 
 ```bash
 npx claudeos-core init
@@ -12,20 +12,50 @@ ClaudeOS-Core liest Ihre Codebasis, extrahiert jedes Muster und generiert einen
 
 ---
 
-## Das Problem
+## Warum ClaudeOS-Core?
 
-Claude Code ist leistungsstark, aber es kennt nicht die Konventionen _Ihres_ Projekts. Das manuelle Schreiben einer `CLAUDE.md`, dutzender Regeln und Scaffolding-Skills dauert Stunden — und sie veralten, sobald sich Ihre Codebasis weiterentwickelt.
+> Mensch beschreibt das Projekt → LLM generiert Dokumentation
 
-## Die Lösung
+ClaudeOS-Core:
 
-ClaudeOS-Core automatisiert den gesamten Prozess:
+> Code analysiert Quellcode → Code baut maßgeschneiderten Prompt → LLM generiert Dokumentation → Code verifiziert Output
 
-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–19 Dateien), Rules, Skills, Guides (9 Dateien), Master Plans, DB-Dokumentation und MCP-Leitfaden
-4. **Validiert** alles — 5 integrierte Verifizierungstools gewährleisten Konsistenz
+### Das Kernproblem: LLMs raten. Code bestätigt.
 
-Gesamtzeit: **5–18 Minuten**, abhängig von der Projektgröße. Null manuelle Konfiguration.
+Wenn Sie Claude bitten, "dieses Projekt zu analysieren", **rät** es Ihren Stack, ORM, Domänenstruktur.
+
+**ClaudeOS-Core rät nicht.** Claude Node.js:
+
+- `build.gradle` / `package.json` / `pyproject.toml` → **confirmed**
+- directory scan → **confirmed**
+- Java 5 patterns, Kotlin CQRS/BFF, Next.js App Router/FSD → **classified**
+- domain groups → **split**
+- stack-specific prompt → **assembled**
+
+### Das Ergebnis
+
+Andere Tools erzeugen "allgemein gute" Dokumentation.
+ClaudeOS-Core erzeugt Dokumentation, die weiß, dass Ihr Projekt `ApiResponse.ok()` verwendet (nicht `ResponseEntity.success()`), dass Ihre MyBatis XML Mapper in `src/main/resources/mapper/{domain}/` liegen — weil es Ihren tatsächlichen Code gelesen hat.
+
+### Before & After
+
+**Ohne ClaudeOS-Core**:
+```
+❌ JPA repository (MyBatis)
+❌ ResponseEntity.success() (ApiResponse.ok())
+❌ order/controller/ (controller/order/)
+→ 20 min fix per file
+```
+
+**Mit ClaudeOS-Core**:
+```
+✅ MyBatis mapper + XML (build.gradle)
+✅ ApiResponse.ok() (source code)
+✅ controller/order/ (Pattern A)
+→ immediate match
+```
+
+Dieser Unterschied summiert sich. 10 Aufgaben/Tag × 20 Minuten gespart = **über 3 Stunden/Tag**.
 
 ---
 
@@ -79,6 +109,7 @@ Unterstützte Modultypen: `command`, `query`, `bff`, `integration`, `standalone`
 - **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)
+- **Tiefe Verzeichnis-Fallback**: Für React/CRA/Vite/Vue/RN-Projekte scannt `**/components/*/`, `**/views/*/`, `**/screens/*/`, `**/containers/*/`, `**/pages/*/`, `**/routes/*/`, `**/modules/*/`, `**/domains/*/` in beliebiger Tiefe
 
 ---
 
@@ -117,7 +148,7 @@ bash claudeos-core-tools/bootstrap.sh
 
 ### Ausgabesprache (10 Sprachen)
 
-Wenn Sie `init` ohne `--lang` ausführen, erscheint ein interaktiver Selektor mit Pfeiltasten:
+Wenn Sie `init` ohne `--lang` ausführen, erscheint ein interaktiver Selektor (Pfeiltasten oder Zifferntasten):
 
 ```
 ╔══════════════════════════════════════════════════╗
@@ -131,7 +162,7 @@ Wenn Sie `init` ohne `--lang` ausführen, erscheint ein interaktiver Selektor mi
      ...
   ❯ 10. de     — Deutsch (German)
 
-  ↑↓ Move  ↵ Select
+  ↑↓ Move  1-0 Jump  Enter Select  ESC Cancel
 ```
 
 Die Beschreibung wechselt beim Navigieren in die entsprechende Sprache. Um den Selektor zu überspringen:
@@ -454,19 +485,31 @@ npx claudeos-core restore
 
 ## Was ist anders?
 
-| | ClaudeOS-Core | SuperClaude | Manuelle CLAUDE.md | Generische Skills |
-|---|---|---|---|---|
-| **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 | ❌ | ❌ | ❌ |
-| **Mehrsprachig** | ✅ 10 Sprachen, interaktiver Selektor | ❌ | ❌ | ❌ |
-| **Selbstverifizierung** | ✅ 5 Validierungstools | ❌ | ❌ | ❌ |
-| **Backup / Wiederherstellung** | ✅ Master Plan System | ❌ | ❌ | ❌ |
-| **Einrichtungszeit** | ~5–18 Min (automatisch) | ~5 Min (manuelle Konfig) | Stunden–Tage | ~5 Min |
+| | ClaudeOS-Core | Everything Claude Code (50K+ ⭐) | Harness | specs-generator | Claude `/init` |
+|---|---|---|---|---|---|
+| **Approach** | Code analyzes first, then LLM generates | Pre-built config presets | LLM designs agent teams | LLM generates spec docs | LLM writes CLAUDE.md |
+| **Reads your source code** | ✅ Deterministic static analysis | ❌ | ❌ | ❌ (LLM reads) | ❌ (LLM reads) |
+| **Stack detection** | Code confirms (ORM, DB, build tool, pkg manager) | N/A (stack-agnostic) | LLM guesses | LLM guesses | LLM guesses |
+| **Domain detection** | Code confirms (Java 5 patterns, Kotlin CQRS, Next.js FSD) | N/A | LLM guesses | N/A | N/A |
+| **Same project → Same result** | ✅ Deterministic analysis | ✅ (static files) | ❌ (LLM varies) | ❌ (LLM varies) | ❌ (LLM varies) |
+| **Large project handling** | Domain group splitting (4 domains / 40 files per group) | N/A | No splitting | No splitting | Context window limit |
+| **Output** | CLAUDE.md + Rules + Standards + Skills + Guides + Plans (40-50+ files) | Agents + Skills + Commands + Hooks | Agents + Skills | 6 spec documents | CLAUDE.md (1 file) |
+| **Output location** | `.claude/rules/` (auto-loaded by Claude Code) | `.claude/` various | `.claude/agents/` + `.claude/skills/` | `.claude/steering/` + `specs/` | `CLAUDE.md` |
+| **Post-generation verification** | ✅ 5 automated validators | ❌ | ❌ | ❌ | ❌ |
+| **Multi-language output** | ✅ 10 languages | ❌ | ❌ | ❌ | ❌ |
+| **Multi-stack** | ✅ Backend + Frontend simultaneous | ❌ Stack-agnostic | ❌ | ❌ | Partial |
+| **Agent orchestration** | ❌ | ✅ 28 agents | ✅ 6 patterns | ❌ | ❌ |
 
----
+### Key difference
 
+**Other tools give Claude "generally good instructions." ClaudeOS-Core gives Claude "instructions extracted from your actual code."**
+
+### Complementary, not competing
+
+ClaudeOS-Core: **project-specific rules**. Other tools: **agent orchestration**.
+Use both together.
+
+---
 ## FAQ
 
 **F: Ändert es meinen Quellcode?**

package/README.es.md

@@ -1,6 +1,6 @@
 # ClaudeOS-Core
 
-**Un solo comando. Toda la documentación de Claude Code — generada automáticamente desde tu código fuente.**
+**La única herramienta que lee tu código fuente primero, confirma tu stack y patrones con análisis determinístico, y genera reglas de Claude Code adaptadas exactamente a tu proyecto.**
 
 ```bash
 npx claudeos-core init
@@ -12,20 +12,50 @@ ClaudeOS-Core lee tu código fuente, extrae cada patrón que encuentra y genera
 
 ---
 
-## El Problema
+## ¿Por qué ClaudeOS-Core?
 
-Claude Code es potente, pero no conoce las convenciones de _tu_ proyecto. Escribir manualmente un `CLAUDE.md`, docenas de reglas y skills de scaffolding lleva horas — y se vuelven obsoletos en cuanto tu código evoluciona.
+> Humano describe el proyecto → LLM genera documentación
 
-## La Solución
+ClaudeOS-Core:
 
-ClaudeOS-Core automatiza todo el proceso:
+> Código analiza tu fuente → Código construye prompt personalizado → LLM genera documentación → Código verifica la salida
 
-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–19 archivos), Rules, Skills, Guides (9 archivos), Master Plans, documentación de BD y guía MCP
-4. **Valida** todo — 5 herramientas de verificación integradas garantizan la consistencia
+### El problema central: Los LLMs adivinan. El código confirma.
 
-Tiempo total: **5–18 minutos**, según el tamaño del proyecto. Cero configuración manual.
+Cuando le pides a Claude "analiza este proyecto", **adivina** tu stack, ORM y estructura de dominios.
+
+**ClaudeOS-Core no adivina.** Claude Node.js:
+
+- `build.gradle` / `package.json` / `pyproject.toml` → **confirmed**
+- directory scan → **confirmed**
+- Java 5 patterns, Kotlin CQRS/BFF, Next.js App Router/FSD → **classified**
+- domain groups → **split**
+- stack-specific prompt → **assembled**
+
+### El resultado
+
+Otras herramientas producen documentación "generalmente buena".
+ClaudeOS-Core produce documentación que sabe que tu proyecto usa `ApiResponse.ok()` (no `ResponseEntity.success()`), que tus mappers MyBatis XML están en `src/main/resources/mapper/{domain}/` — porque leyó tu código real.
+
+### Before & After
+
+**Sin ClaudeOS-Core**:
+```
+❌ JPA repository (MyBatis)
+❌ ResponseEntity.success() (ApiResponse.ok())
+❌ order/controller/ (controller/order/)
+→ 20 min fix per file
+```
+
+**Con ClaudeOS-Core**:
+```
+✅ MyBatis mapper + XML (build.gradle)
+✅ ApiResponse.ok() (source code)
+✅ controller/order/ (Pattern A)
+→ immediate match
+```
+
+Esta diferencia se acumula. 10 tareas/día × 20 minutos ahorrados = **más de 3 horas/día**.
 
 ---
 
@@ -79,6 +109,7 @@ Tipos de módulo soportados: `command`, `query`, `bff`, `integration`, `standalo
 - **FSD (Feature-Sliced Design)**: `features/*/`, `widgets/*/`, `entities/*/`
 - **RSC/Client split**: Detecta patrón `client.tsx`, rastrea separación Server/Client
 - **Config fallback**: Detecta Next.js/Vite/Nuxt desde archivos de configuración (soporte monorepo)
+- **Fallback de directorios profundos**: Para proyectos React/CRA/Vite/Vue/RN, escanea `**/components/*/`, `**/views/*/`, `**/screens/*/`, `**/containers/*/`, `**/pages/*/`, `**/routes/*/`, `**/modules/*/`, `**/domains/*/` a cualquier profundidad
 
 ---
 
@@ -117,7 +148,7 @@ bash claudeos-core-tools/bootstrap.sh
 
 ### Idioma de salida (10 idiomas)
 
-Al ejecutar `init` sin `--lang`, aparece un selector interactivo con teclas de flecha:
+Al ejecutar `init` sin `--lang`, aparece un selector interactivo con teclas de flecha o teclas numéricas:
 
 ```
 ╔══════════════════════════════════════════════════╗
@@ -132,7 +163,7 @@ Al ejecutar `init` sin `--lang`, aparece un selector interactivo con teclas de f
   ❯  5. es     — Español (Spanish)
      ...
 
-  ↑↓ Move  ↵ Select
+  ↑↓ Move  1-0 Jump  Enter Select  ESC Cancel
 ```
 
 La descripción cambia al idioma seleccionado al navegar. Para saltar el selector:
@@ -455,19 +486,31 @@ npx claudeos-core restore
 
 ## ¿En Qué se Diferencia?
 
-| | ClaudeOS-Core | SuperClaude | CLAUDE.md Manual | Skills Genéricos |
-|---|---|---|---|---|
-| **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 | ❌ | ❌ | ❌ |
-| **Multi-idioma** | ✅ 10 idiomas, selector interactivo | ❌ | ❌ | ❌ |
-| **Auto-verificación** | ✅ 5 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 |
+| | ClaudeOS-Core | Everything Claude Code (50K+ ⭐) | Harness | specs-generator | Claude `/init` |
+|---|---|---|---|---|---|
+| **Approach** | Code analyzes first, then LLM generates | Pre-built config presets | LLM designs agent teams | LLM generates spec docs | LLM writes CLAUDE.md |
+| **Reads your source code** | ✅ Deterministic static analysis | ❌ | ❌ | ❌ (LLM reads) | ❌ (LLM reads) |
+| **Stack detection** | Code confirms (ORM, DB, build tool, pkg manager) | N/A (stack-agnostic) | LLM guesses | LLM guesses | LLM guesses |
+| **Domain detection** | Code confirms (Java 5 patterns, Kotlin CQRS, Next.js FSD) | N/A | LLM guesses | N/A | N/A |
+| **Same project → Same result** | ✅ Deterministic analysis | ✅ (static files) | ❌ (LLM varies) | ❌ (LLM varies) | ❌ (LLM varies) |
+| **Large project handling** | Domain group splitting (4 domains / 40 files per group) | N/A | No splitting | No splitting | Context window limit |
+| **Output** | CLAUDE.md + Rules + Standards + Skills + Guides + Plans (40-50+ files) | Agents + Skills + Commands + Hooks | Agents + Skills | 6 spec documents | CLAUDE.md (1 file) |
+| **Output location** | `.claude/rules/` (auto-loaded by Claude Code) | `.claude/` various | `.claude/agents/` + `.claude/skills/` | `.claude/steering/` + `specs/` | `CLAUDE.md` |
+| **Post-generation verification** | ✅ 5 automated validators | ❌ | ❌ | ❌ | ❌ |
+| **Multi-language output** | ✅ 10 languages | ❌ | ❌ | ❌ | ❌ |
+| **Multi-stack** | ✅ Backend + Frontend simultaneous | ❌ Stack-agnostic | ❌ | ❌ | Partial |
+| **Agent orchestration** | ❌ | ✅ 28 agents | ✅ 6 patterns | ❌ | ❌ |
 
----
+### Key difference
 
+**Other tools give Claude "generally good instructions." ClaudeOS-Core gives Claude "instructions extracted from your actual code."**
+
+### Complementary, not competing
+
+ClaudeOS-Core: **project-specific rules**. Other tools: **agent orchestration**.
+Use both together.
+
+---
 ## FAQ
 
 **P: ¿Modifica mi código fuente?**

package/README.fr.md

@@ -1,6 +1,6 @@
 # ClaudeOS-Core
 
-**Une seule commande. Toute votre documentation Claude Code — générée automatiquement à partir de votre code source.**
+**Le seul outil qui lit d'abord votre code source, confirme votre stack et vos patterns par une analyse déterministe, puis génère des règles Claude Code adaptées exactement à votre projet.**
 
 ```bash
 npx claudeos-core init
@@ -12,20 +12,50 @@ ClaudeOS-Core lit votre codebase, extrait chaque pattern qu'il trouve et génèr
 
 ---
 
-## Le Problème
+## Pourquoi ClaudeOS-Core ?
 
-Claude Code est puissant, mais il ne connaît pas les conventions de _votre_ projet. Écrire manuellement un `CLAUDE.md`, des dizaines de règles et des skills de scaffolding prend des heures — et ils deviennent obsolètes dès que votre codebase évolue.
+> L'humain décrit le projet → Le LLM génère la documentation
 
-## La Solution
+ClaudeOS-Core:
 
-ClaudeOS-Core automatise l'ensemble du processus :
+> Le code analyse vos sources → Le code construit un prompt personnalisé → Le LLM génère la documentation → Le code vérifie la sortie
 
-1. **Scanne** votre projet — détecte automatiquement le stack, les domaines, l'ORM, la base de données et le gestionnaire de paquets
-2. **Analyse en profondeur** votre code source — patterns de contrôleurs, couches de service, conventions de nommage, gestion des erreurs, sécurité, tests et plus de 50 catégories
-3. **Génère** un écosystème documentaire complet — `CLAUDE.md`, Standards (15–19 fichiers), Rules, Skills, Guides (9 fichiers), Master Plans, documentation BD et guide MCP
-4. **Valide** tout — 5 outils de vérification intégrés garantissent la cohérence
+### Le problème fondamental : les LLMs devinent. Le code confirme.
 
-Temps total : **5–18 minutes**, selon la taille du projet. Zéro configuration manuelle.
+Quand vous demandez à Claude d'« analyser ce projet », il **devine** votre stack, ORM, structure de domaines.
+
+**ClaudeOS-Core ne devine pas.** Claude Node.js:
+
+- `build.gradle` / `package.json` / `pyproject.toml` → **confirmed**
+- directory scan → **confirmed**
+- Java 5 patterns, Kotlin CQRS/BFF, Next.js App Router/FSD → **classified**
+- domain groups → **split**
+- stack-specific prompt → **assembled**
+
+### Le résultat
+
+Les autres outils produisent une documentation « généralement bonne ».
+ClaudeOS-Core produit une documentation qui sait que votre projet utilise `ApiResponse.ok()` (pas `ResponseEntity.success()`), que vos mappers MyBatis XML sont dans `src/main/resources/mapper/{domain}/` — parce qu'il a lu votre vrai code.
+
+### Before & After
+
+**Sans ClaudeOS-Core**:
+```
+❌ JPA repository (MyBatis)
+❌ ResponseEntity.success() (ApiResponse.ok())
+❌ order/controller/ (controller/order/)
+→ 20 min fix per file
+```
+
+**Avec ClaudeOS-Core**:
+```
+✅ MyBatis mapper + XML (build.gradle)
+✅ ApiResponse.ok() (source code)
+✅ controller/order/ (Pattern A)
+→ immediate match
+```
+
+Cette différence s'accumule. 10 tâches/jour × 20 minutes économisées = **plus de 3 heures/jour**.
 
 ---
 
@@ -79,6 +109,7 @@ Types de modules supportés : `command`, `query`, `bff`, `integration`, `standal
 - **FSD (Feature-Sliced Design)** : `features/*/`, `widgets/*/`, `entities/*/`
 - **RSC/Client split** : Détecte le pattern `client.tsx`, suit la séparation Server/Client
 - **Fallback config** : Détecte Next.js/Vite/Nuxt depuis les fichiers de config (support monorepo)
+- **Fallback répertoires profonds** : Pour les projets React/CRA/Vite/Vue/RN, scanne `**/components/*/`, `**/views/*/`, `**/screens/*/`, `**/containers/*/`, `**/pages/*/`, `**/routes/*/`, `**/modules/*/`, `**/domains/*/` à toute profondeur
 
 ---
 
@@ -117,7 +148,7 @@ bash claudeos-core-tools/bootstrap.sh
 
 ### Langue de sortie (10 langues)
 
-En exécutant `init` sans `--lang`, un sélecteur interactif avec les touches fléchées apparaît :
+En exécutant `init` sans `--lang`, un sélecteur interactif apparaît (touches fléchées ou touches numériques) :
 
 ```
 ╔══════════════════════════════════════════════════╗
@@ -132,7 +163,7 @@ En exécutant `init` sans `--lang`, un sélecteur interactif avec les touches fl
   ❯  9. fr     — Français (French)
      ...
 
-  ↑↓ Move  ↵ Select
+  ↑↓ Move  1-0 Jump  Enter Select  ESC Cancel
 ```
 
 La description change dans la langue correspondante lors de la navigation. Pour passer le sélecteur :
@@ -455,19 +486,31 @@ npx claudeos-core restore
 
 ## Quelle Différence ?
 
-| | ClaudeOS-Core | SuperClaude | CLAUDE.md Manuel | Skills Génériques |
-|---|---|---|---|---|
-| **Lit votre code** | ✅ Analyse approfondie (55–95 catégories) | ❌ Injection de comportement | ❌ Écriture manuelle | ❌ Templates prédéfinis |
-| **Sortie spécifique au projet** | ✅ Chaque fichier reflète vos patterns | ❌ Commandes génériques | Partiel | ❌ Taille unique |
-| **Multi-stack** | ✅ Auto-détection + analyse séparée | ❌ Agnostique au stack | Manuel | Variable |
-| **Kotlin + CQRS/BFF** | ✅ Multi-module, Command/Query split | ❌ | ❌ | ❌ |
-| **Multilingue** | ✅ 10 langues, sélecteur interactif | ❌ | ❌ | ❌ |
-| **Auto-vérification** | ✅ 5 outils de validation | ❌ | ❌ | ❌ |
-| **Sauvegarde / Restauration** | ✅ Système Master Plan | ❌ | ❌ | ❌ |
-| **Temps de configuration** | ~5–18 min (automatique) | ~5 min (config manuelle) | Heures–Jours | ~5 min |
+| | ClaudeOS-Core | Everything Claude Code (50K+ ⭐) | Harness | specs-generator | Claude `/init` |
+|---|---|---|---|---|---|
+| **Approach** | Code analyzes first, then LLM generates | Pre-built config presets | LLM designs agent teams | LLM generates spec docs | LLM writes CLAUDE.md |
+| **Reads your source code** | ✅ Deterministic static analysis | ❌ | ❌ | ❌ (LLM reads) | ❌ (LLM reads) |
+| **Stack detection** | Code confirms (ORM, DB, build tool, pkg manager) | N/A (stack-agnostic) | LLM guesses | LLM guesses | LLM guesses |
+| **Domain detection** | Code confirms (Java 5 patterns, Kotlin CQRS, Next.js FSD) | N/A | LLM guesses | N/A | N/A |
+| **Same project → Same result** | ✅ Deterministic analysis | ✅ (static files) | ❌ (LLM varies) | ❌ (LLM varies) | ❌ (LLM varies) |
+| **Large project handling** | Domain group splitting (4 domains / 40 files per group) | N/A | No splitting | No splitting | Context window limit |
+| **Output** | CLAUDE.md + Rules + Standards + Skills + Guides + Plans (40-50+ files) | Agents + Skills + Commands + Hooks | Agents + Skills | 6 spec documents | CLAUDE.md (1 file) |
+| **Output location** | `.claude/rules/` (auto-loaded by Claude Code) | `.claude/` various | `.claude/agents/` + `.claude/skills/` | `.claude/steering/` + `specs/` | `CLAUDE.md` |
+| **Post-generation verification** | ✅ 5 automated validators | ❌ | ❌ | ❌ | ❌ |
+| **Multi-language output** | ✅ 10 languages | ❌ | ❌ | ❌ | ❌ |
+| **Multi-stack** | ✅ Backend + Frontend simultaneous | ❌ Stack-agnostic | ❌ | ❌ | Partial |
+| **Agent orchestration** | ❌ | ✅ 28 agents | ✅ 6 patterns | ❌ | ❌ |
 
----
+### Key difference
 
+**Other tools give Claude "generally good instructions." ClaudeOS-Core gives Claude "instructions extracted from your actual code."**
+
+### Complementary, not competing
+
+ClaudeOS-Core: **project-specific rules**. Other tools: **agent orchestration**.
+Use both together.
+
+---
 ## FAQ
 
 **Q : Est-ce que ça modifie mon code source ?**

package/README.hi.md

@@ -1,6 +1,6 @@
 # ClaudeOS-Core
 
-**एक कमांड। आपका पूरा Claude Code डॉक्यूमेंटेशन — आपके वास्तविक सोर्स कोड से ऑटो-जेनरेट।**
+**एकमात्र टूल जो पहले आपका सोर्स कोड पढ़ता है, deterministic एनालिसिस से स्टैक और पैटर्न कन्फर्म करता है, फिर आपके प्रोजेक्ट के लिए सटीक Claude Code रूल्स जेनरेट करता है।**
 
 ```bash
 npx claudeos-core init
@@ -12,20 +12,50 @@ ClaudeOS-Core आपका कोडबेस पढ़ता है, हर प
 
 ---
 
-## समस्या
+## ClaudeOS-Core क्यों?
 
-Claude Code शक्तिशाली है, लेकिन यह _आपके_ प्रोजेक्ट की कन्वेंशन्स को नहीं जानता। मैन्युअली `CLAUDE.md`, दर्जनों rules और scaffolding skills लिखने में घंटों लगते हैं — और कोडबेस बदलते ही ये पुराने हो जाते हैं।
+> इंसान प्रोजेक्ट का वर्णन करता है → LLM डॉक्यूमेंटेशन जेनरेट करता है
 
-## समाधान
+ClaudeOS-Core:
 
-ClaudeOS-Core पूरी प्रक्रिया को ऑटोमेट करता है:
+> कोड सोर्स का विश्लेषण करता है → कोड कस्टम प्रॉम्प्ट बनाता है → LLM डॉक्यूमेंटेशन जेनरेट करता है → कोड आउटपुट को वेरिफाई करता है
 
-1. **स्कैन** — स्टैक, डोमेन, ORM, डेटाबेस, पैकेज मैनेजर ऑटो-डिटेक्ट
-2. **गहन विश्लेषण** — कंट्रोलर पैटर्न, सर्विस लेयर्स, नेमिंग कन्वेंशन, एरर हैंडलिंग, सिक्योरिटी, टेस्टिंग और 50+ कैटेगरी
-3. **जेनरेट** — `CLAUDE.md`, Standards (15–19 फाइलें), Rules, Skills, Guides (9 फाइलें), Master Plans, DB डॉक्स और MCP गाइड का पूरा डॉक्यूमेंटेशन इकोसिस्टम
-4. **वैलिडेट** — 5 बिल्ट-इन वेरिफिकेशन टूल्स कंसिस्टेंसी सुनिश्चित करते हैं
+### मूल समस्या: LLM अनुमान लगाता है। कोड कन्फर्म करता है।
 
-कुल समय: प्रोजेक्ट साइज़ के अनुसार **5–18 मिनट**। शून्य मैन्युअल कॉन्फ़िगरेशन।
+जब आप Claude से "इस प्रोजेक्ट का विश्लेषण करो" कहते हैं, तो यह स्टैक, ORM, डोमेन स्ट्रक्चर का **अनुमान** लगाता है।
+
+**ClaudeOS-Core अनुमान नहीं लगाता।** Claude Node.js:
+
+- `build.gradle` / `package.json` / `pyproject.toml` → **confirmed**
+- directory scan → **confirmed**
+- Java 5 patterns, Kotlin CQRS/BFF, Next.js App Router/FSD → **classified**
+- domain groups → **split**
+- stack-specific prompt → **assembled**
+
+### परिणाम
+
+अन्य टूल "सामान्य रूप से अच्छा" डॉक्यूमेंटेशन बनाते हैं।
+ClaudeOS-Core ऐसा डॉक्यूमेंटेशन बनाता है जो जानता है कि प्रोजेक्ट `ApiResponse.ok()` इस्तेमाल करता है — क्योंकि इसने वास्तविक कोड पढ़ा है।
+
+### Before & After
+
+**ClaudeOS-Core के बिना**:
+```
+❌ JPA repository (MyBatis)
+❌ ResponseEntity.success() (ApiResponse.ok())
+❌ order/controller/ (controller/order/)
+→ 20 min fix per file
+```
+
+**ClaudeOS-Core के साथ**:
+```
+✅ MyBatis mapper + XML (build.gradle)
+✅ ApiResponse.ok() (source code)
+✅ controller/order/ (Pattern A)
+→ immediate match
+```
+
+यह अंतर संचयी है। प्रतिदिन 10 कार्य × 20 मिनट बचत = **प्रतिदिन 3+ घंटे**।
 
 ---
 
@@ -79,6 +109,7 @@ Gradle मल्टी-मॉड्यूल संरचना वाले Kot
 - **FSD (Feature-Sliced Design)**: `features/*/`, `widgets/*/`, `entities/*/`
 - **RSC/Client split**: `client.tsx` पैटर्न डिटेक्ट, Server/Client कम्पोनेंट सेपरेशन ट्रैक
 - **Config fallback**: `package.json` में न होने पर भी config फ़ाइलों से Next.js/Vite/Nuxt डिटेक्ट (monorepo सपोर्ट)
+- **Deep directory fallback**: React/CRA/Vite/Vue/RN प्रोजेक्ट्स के लिए किसी भी गहराई पर `**/components/*/`, `**/views/*/`, `**/screens/*/`, `**/containers/*/`, `**/pages/*/`, `**/routes/*/`, `**/modules/*/`, `**/domains/*/` स्कैन
 
 ---
 
@@ -117,7 +148,7 @@ bash claudeos-core-tools/bootstrap.sh
 
 ### आउटपुट भाषा (10 भाषाएँ)
 
-`--lang` के बिना `init` चलाने पर, एरो कीज़ से भाषा चुनने का इंटरैक्टिव सेलेक्टर दिखाई देगा:
+`--lang` के बिना `init` चलाने पर, एरो कीज़ या नंबर कीज़ से भाषा चुनने का इंटरैक्टिव सेलेक्टर दिखाई देगा:
 
 ```
 ╔══════════════════════════════════════════════════╗
@@ -132,10 +163,10 @@ bash claudeos-core-tools/bootstrap.sh
   ❯  7. hi     — हिन्दी (Hindi)
      ...
 
-  ↑↓ Move  ↵ Select
+  ↑↓ Move  1-0 Jump  Enter Select  ESC Cancel
 ```
 
-एरो से मूव करने पर विवरण उस भाषा में बदलता है। सेलेक्टर स्किप करने के लिए:
+सेलेक्शन मूव करने पर विवरण उस भाषा में बदलता है। सेलेक्टर स्किप करने के लिए:
 
 ```bash
 npx claudeos-core init --lang hi    # हिन्दी
@@ -455,19 +486,31 @@ npx claudeos-core restore
 
 ## क्या अलग है?
 
-| | ClaudeOS-Core | SuperClaude | मैन्युअल CLAUDE.md | जेनेरिक Skills |
-|---|---|---|---|---|
-| **कोड पढ़ता है** | ✅ गहन विश्लेषण (55–95 कैटेगरी) | ❌ बिहेवियर इंजेक्शन | ❌ मैन्युअल राइटिंग | ❌ प्री-बिल्ट टेम्पलेट |
-| **प्रोजेक्ट-स्पेसिफिक आउटपुट** | ✅ हर फाइल आपके पैटर्न रिफ्लेक्ट करती है | ❌ जेनेरिक कमांड | आंशिक | ❌ वन-साइज़-फिट्स-ऑल |
-| **मल्टी-स्टैक** | ✅ ऑटो-डिटेक्ट + अलग विश्लेषण | ❌ स्टैक-एग्नॉस्टिक | मैन्युअल | अनिश्चित |
-| **Kotlin + CQRS/BFF** | ✅ मल्टी-मॉड्यूल, Command/Query विभाजन | ❌ | ❌ | ❌ |
-| **बहुभाषी** | ✅ 10 भाषाएँ, इंटरैक्टिव सेलेक्टर | ❌ | ❌ | ❌ |
-| **सेल्फ-वेरिफाइंग** | ✅ 5 वैलिडेशन टूल्स | ❌ | ❌ | ❌ |
-| **बैकअप / रीस्टोर** | ✅ Master Plan सिस्टम | ❌ | ❌ | ❌ |
-| **सेटअप समय** | ~5–18 मिनट (ऑटोमेटेड) | ~5 मिनट (मैन्युअल कॉन्फ़िग) | घंटे–दिन | ~5 मिनट |
+| | ClaudeOS-Core | Everything Claude Code (50K+ ⭐) | Harness | specs-generator | Claude `/init` |
+|---|---|---|---|---|---|
+| **Approach** | Code analyzes first, then LLM generates | Pre-built config presets | LLM designs agent teams | LLM generates spec docs | LLM writes CLAUDE.md |
+| **Reads your source code** | ✅ Deterministic static analysis | ❌ | ❌ | ❌ (LLM reads) | ❌ (LLM reads) |
+| **Stack detection** | Code confirms (ORM, DB, build tool, pkg manager) | N/A (stack-agnostic) | LLM guesses | LLM guesses | LLM guesses |
+| **Domain detection** | Code confirms (Java 5 patterns, Kotlin CQRS, Next.js FSD) | N/A | LLM guesses | N/A | N/A |
+| **Same project → Same result** | ✅ Deterministic analysis | ✅ (static files) | ❌ (LLM varies) | ❌ (LLM varies) | ❌ (LLM varies) |
+| **Large project handling** | Domain group splitting (4 domains / 40 files per group) | N/A | No splitting | No splitting | Context window limit |
+| **Output** | CLAUDE.md + Rules + Standards + Skills + Guides + Plans (40-50+ files) | Agents + Skills + Commands + Hooks | Agents + Skills | 6 spec documents | CLAUDE.md (1 file) |
+| **Output location** | `.claude/rules/` (auto-loaded by Claude Code) | `.claude/` various | `.claude/agents/` + `.claude/skills/` | `.claude/steering/` + `specs/` | `CLAUDE.md` |
+| **Post-generation verification** | ✅ 5 automated validators | ❌ | ❌ | ❌ | ❌ |
+| **Multi-language output** | ✅ 10 languages | ❌ | ❌ | ❌ | ❌ |
+| **Multi-stack** | ✅ Backend + Frontend simultaneous | ❌ Stack-agnostic | ❌ | ❌ | Partial |
+| **Agent orchestration** | ❌ | ✅ 28 agents | ✅ 6 patterns | ❌ | ❌ |
 
----
+### Key difference
 
+**Other tools give Claude "generally good instructions." ClaudeOS-Core gives Claude "instructions extracted from your actual code."**
+
+### Complementary, not competing
+
+ClaudeOS-Core: **project-specific rules**. Other tools: **agent orchestration**.
+Use both together.
+
+---
 ## FAQ
 
 **प्र: क्या यह मेरा सोर्स कोड मॉडिफाई करता है?**