claudeos-core 1.5.1 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.6.0] — 2026-04-08
+
+### Added
+
+- **JS/TS monorepo support** — Auto-detect `turbo.json`, `pnpm-workspace.yaml`, `lerna.json`, `package.json#workspaces`; scan sub-package `package.json` for framework/ORM/DB dependencies; domain scanning covers `apps/*/src/` and `packages/*/src/` patterns
+- **NestJS dedicated template (`node-nestjs`)** — Separate analysis prompts for `@Module`, `@Injectable`, `@Controller`, Guards, Pipes, Interceptors, DI container, CQRS, `Test.createTestingModule`; previously shared `node-express` template
+- **Vue/Nuxt dedicated template (`vue-nuxt`)** — Separate analysis prompts for Composition API, `<script setup>`, Pinia, `useFetch`/`useAsyncData`, Nitro server routes, `@nuxt/test-utils`; previously shared `node-nextjs` template
+- **Elapsed time tracking** — CLI shows per-pass elapsed time and total time in completion banner
+- **169 new tests** (87 → 256) — Full coverage for `scan-frontend.js` (4-stage fallback), `scan-kotlin.js` (CQRS, shared query resolution), `scan-node.js`, `scan-python.js`, `prompt-generator.js` (multi-stack), `lang-selector.js`, `resume-selector.js`, `init.js`, `plan-parser.js`, monorepo detection
+- **README updates (10 languages)** — Updated all README files (en, ko, zh-CN, ja, es, vi, hi, ru, fr, de) to reflect new stacks table (NestJS/Vue split), monorepo root execution, facade/usecase/orchestrator detection, template structure, 3 new FAQ entries, 256 test count
+
+### Fixed
+
+- **Windows backslash glob in `scan-kotlin.js`** — glob returns backslash paths on Windows, causing multi-module detection to silently fail; added `norm()` normalization (no-op on Unix)
+- **Kotlin module key collision** — When same module name exists under different parents (e.g., `servers/command/api-server` + `servers/query/api-server`), both entries now upgrade to full key; `domainMap` merges counts instead of overwriting
+- **Java facade/usecase/orchestrator detection** — `scan-java.js` now detects `facade/`, `usecase/`, `orchestrator/` directories as service-layer (previously only `aggregator/`)
+- **Verification tools exit code** — 4 tools (`content-validator`, `plan-validator`, `sync-checker`, `pass-json-validator`) now exit(1) on unexpected errors instead of exit(0); `health-checker` wrapped in try/catch
+
+### Changed
+
+- **`lib/plan-parser.js`** (new) — Extracted shared `parseFileBlocks`, `parseCodeBlocks`, `replaceFileBlock`, `replaceCodeBlock`, `CODE_BLOCK_PLANS` from `manifest-generator` and `plan-validator`; eliminates duplicate code across 2 files
+- **`lib/stale-report.js`** (new) — Extracted shared `updateStaleReport()` from 6 verification tools; eliminates copy-paste pattern
+- **`cli-utils.js`** — `ensureDir` and `fileExists` now delegate to `lib/safe-fs.js` (single source of truth)
+- **`prompt-generator.js`** — Removed dead strip regex (no template matched these patterns)
+- **`init.js` process.exit refactoring** — `process.exit(1)` replaced with `throw InitError`; `lang-selector.js` and `resume-selector.js` return `null` instead of calling `process.exit()`; all errors handled centrally in `cli.js`
+
 ## [1.5.1] — 2026-04-06
 
 ### Fixed

package/README.de.md

@@ -65,14 +65,16 @@ Dieser Unterschied summiert sich. 10 Aufgaben/Tag × 20 Minuten gespart = **übe
 |---|---|---|
 | **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 |
+| **Node.js / Express** | `package.json` | 9 Kategorien, 57 Unterpunkte |
+| **Node.js / NestJS** | `package.json` (`@nestjs/core`) | 10 Kategorien, 68 Unterpunkte |
+| **Next.js / React** | `package.json`, `next.config.*`, FSD-Unterstützung | 9 Kategorien, 55 Unterpunkte |
+| **Vue / Nuxt** | `package.json`, `nuxt.config.*`, Composition API | 9 Kategorien, 58 Unterpunkte |
 | **Python / Django** | `requirements.txt`, `pyproject.toml` | 10 Kategorien, 55 Unterpunkte |
 | **Python / FastAPI** | `requirements.txt`, `pyproject.toml` | 10 Kategorien, 58 Unterpunkte |
 | **Node.js / Fastify** | `package.json` | 10 Kategorien, 62 Unterpunkte |
 | **Angular** | `package.json`, `angular.json` | 12 Kategorien, 78 Unterpunkte |
 
-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).
+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), Monorepo (Turborepo, pnpm-workspace, Lerna, npm/yarn workspaces).
 
 **Sie müssen nichts angeben. Alles wird automatisch erkannt.**
 
@@ -87,7 +89,7 @@ Automatisch erkannt: Sprache und Version, Framework und Version, ORM (MyBatis, J
 | 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 über die Verzeichnisse `service/`, `dao/`, `aggregator/`, `mapper/`, `repository/` erkannt. Übersprungen: `common`, `config`, `util`, `core`, `front`, `admin`, `v1`, `v2` usw.
+Domains nur mit Services (ohne Controller) werden ebenfalls über die Verzeichnisse `service/`, `dao/`, `aggregator/`, `facade/`, `usecase/`, `orchestrator/`, `mapper/`, `repository/` erkannt. Übersprungen: `common`, `config`, `util`, `core`, `front`, `admin`, `v1`, `v2` usw.
 
 
 ### Kotlin Multi-Modul Domain-Erkennung
@@ -177,7 +179,7 @@ npx claudeos-core init --lang ko    # 한국어
 
 > **Hinweis:** Dies ändert nur die Sprache der generierten Dokumentationsdateien. Die Codeanalyse (Pass 1–2) läuft immer auf Englisch; nur das generierte Ergebnis (Pass 3) wird in der gewählten Sprache geschrieben.
 
-Das war's. Nach 5–18 Minuten ist die gesamte Dokumentation generiert und einsatzbereit.
+Das war's. Nach 5–18 Minuten ist die gesamte Dokumentation generiert und einsatzbereit. Die CLI zeigt die verstrichene Zeit pro Pass und die Gesamtzeit im Abschlussbanner an.
 
 ### Manuelle Schritt-für-Schritt-Installation
 
@@ -529,6 +531,15 @@ Vollständig unterstützt. ClaudeOS-Core erkennt automatisch beide Stacks, taggt
 **F: Was passiert bei erneutem Ausführen?**
 Wenn vorherige Pass 1/2-Ergebnisse existieren, können Sie über einen interaktiven Prompt wählen: **Continue** (dort fortfahren, wo es aufgehört hat) oder **Fresh** (alles löschen und neu starten). Verwenden Sie `--force`, um den Prompt zu überspringen und immer neu zu starten. Pass 3 wird immer erneut ausgeführt. Frühere Versionen können aus Master Plans wiederhergestellt werden.
 
+**F: Funktioniert es mit Turborepo / pnpm Workspaces / Lerna Monorepos?**
+Ja. ClaudeOS-Core erkennt `turbo.json`, `pnpm-workspace.yaml`, `lerna.json` oder `package.json#workspaces` und scannt automatisch die `package.json`-Dateien der Unterpakete nach Framework-/ORM-/DB-Abhängigkeiten. Domain-Scanning deckt `apps/*/src/`- und `packages/*/src/`-Muster ab. Führen Sie es vom Monorepo-Root aus.
+
+**F: Bekommt NestJS ein eigenes Template oder nutzt es das Express-Template?**
+NestJS verwendet ein dediziertes `node-nestjs`-Template mit NestJS-spezifischen Analysekategorien: `@Module`, `@Injectable`, `@Controller`-Dekoratoren, Guards, Pipes, Interceptors, DI-Container, CQRS-Patterns und `Test.createTestingModule`. Express-Projekte verwenden das separate `node-express`-Template.
+
+**F: Was ist mit Vue / Nuxt-Projekten?**
+Vue/Nuxt verwendet ein dediziertes `vue-nuxt`-Template, das Composition API, `<script setup>`, defineProps/defineEmits, Pinia Stores, `useFetch`/`useAsyncData`, Nitro Server Routes und `@nuxt/test-utils` abdeckt. Next.js/React-Projekte verwenden das `node-nextjs`-Template.
+
 **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.).
 
@@ -547,50 +558,66 @@ 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)
+├── node-express/            # Node.js / Express
+├── node-nestjs/             # Node.js / NestJS (Module, DI, Guard, Pipe, Interceptor)
 ├── node-fastify/            # Node.js / Fastify
+├── node-nextjs/             # Next.js / React
+├── vue-nuxt/                # Vue / Nuxt (Composition API, Pinia, Nitro)
 ├── angular/                 # Angular
+├── python-django/           # Python / Django (DRF)
 └── python-fastapi/          # Python / FastAPI
 ```
 
-`plan-installer` erkennt automatisch Ihren Stack / Ihre Stacks und stellt typspezifische Prompts zusammen. Für Multi-Stack-Projekte werden `pass1-backend-prompt.md` und `pass1-frontend-prompt.md` separat generiert, während `pass3-prompt.md` die Generierungsziele beider Stacks kombiniert.
+`plan-installer` erkennt automatisch Ihren Stack / Ihre Stacks und stellt typspezifische Prompts zusammen. NestJS und Vue/Nuxt verwenden dedizierte Templates mit frameworkspezifischen Analysekategorien (z.B. `@Module`/`@Injectable`/Guards für NestJS, `<script setup>`/Pinia/useFetch für Vue). Für Multi-Stack-Projekte werden `pass1-backend-prompt.md` und `pass1-frontend-prompt.md` separat generiert, während `pass3-prompt.md` die Generierungsziele beider Stacks kombiniert.
 
 ---
 
 ## Monorepo-Unterstützung
 
-ClaudeOS-Core liest die `package.json` im **aktuellen Verzeichnis**. In Monorepo-Setups (Turborepo, Nx, Lerna, pnpm Workspaces) enthält die Root-`package.json` oft keine Framework-Abhängigkeiten wie `next`, `express` oder `react` — diese befinden sich in den einzelnen App-Verzeichnissen.
+ClaudeOS-Core erkennt automatisch JS/TS-Monorepo-Setups und scannt Unterpakete nach Abhängigkeiten.
 
-**Führen Sie ClaudeOS-Core vom App-Verzeichnis aus, nicht vom Monorepo-Root:**
+**Unterstützte Monorepo-Marker** (automatisch erkannt):
+- `turbo.json` (Turborepo)
+- `pnpm-workspace.yaml` (pnpm Workspaces)
+- `lerna.json` (Lerna)
+- `package.json#workspaces` (npm/yarn Workspaces)
 
-```bash
-# Beispiel: Turborepo mit apps/my-app
-cd apps/my-app
-npx claudeos-core init
+**Führen Sie ClaudeOS-Core vom Monorepo-Root aus** — ClaudeOS-Core liest `apps/*/package.json` und `packages/*/package.json`, um Framework-/ORM-/DB-Abhängigkeiten über Unterpakete hinweg zu erkennen:
 
-# Beispiel: Nx Workspace
-cd apps/frontend
+```bash
+cd my-monorepo
 npx claudeos-core init
 ```
 
-Jede App erhält ihren eigenen unabhängigen Satz von Standards, Rules, Skills und Guides, die auf den Stack und die Muster dieser spezifischen App zugeschnitten sind.
+**Was erkannt wird:**
+- Abhängigkeiten aus `apps/web/package.json` (z.B. `next`, `react`) → Frontend-Stack
+- Abhängigkeiten aus `apps/api/package.json` (z.B. `express`, `prisma`) → Backend-Stack
+- Abhängigkeiten aus `packages/db/package.json` (z.B. `drizzle-orm`) → ORM/DB
+- Benutzerdefinierte Workspace-Pfade aus `pnpm-workspace.yaml` (z.B. `services/*`)
 
-**Typische Monorepo-Struktur:**
+**Domain-Scanning deckt auch Monorepo-Layouts ab:**
+- `apps/api/src/modules/*/` und `apps/api/src/*/` für Backend-Domains
+- `apps/web/app/*/`, `apps/web/src/app/*/`, `apps/web/pages/*/` für Frontend-Domains
+- `packages/*/src/*/` für gemeinsame Paket-Domains
 
 ```
-my-monorepo/                    ← Nicht hier ausführen (Root hat keine Framework-Deps)
+my-monorepo/                    ← Hier ausführen: npx claudeos-core init
+├── turbo.json                  ← Automatisch als Turborepo erkannt
 ├── apps/
-│   ├── web/                    ← Hier ausführen: cd apps/web && npx claudeos-core init
-│   ├── api/                    ← Hier ausführen: cd apps/api && npx claudeos-core init
-│   └── storybook/
+│   ├── web/                    ← Next.js erkannt aus apps/web/package.json
+│   │   ├── app/dashboard/      ← Frontend-Domain erkannt
+│   │   └── package.json        ← { "dependencies": { "next": "^14" } }
+│   └── api/                    ← Express erkannt aus apps/api/package.json
+│       ├── src/modules/users/  ← Backend-Domain erkannt
+│       └── package.json        ← { "dependencies": { "express": "^4" } }
 ├── packages/
-│   ├── ui/
-│   └── utils/
-└── package.json                ← Nur devDependencies (turbo, eslint usw.)
+│   ├── db/                     ← Drizzle erkannt aus packages/db/package.json
+│   └── ui/
+└── package.json                ← { "workspaces": ["apps/*", "packages/*"] }
 ```
 
+> **Hinweis:** Für Kotlin/Java-Monorepos verwendet die Multi-Modul-Erkennung `settings.gradle.kts` (siehe [Kotlin Multi-Modul Domain-Erkennung](#kotlin-multi-modul-domain-erkennung) oben) und erfordert keine JS-Monorepo-Marker.
+
 ## Fehlerbehebung
 
 **"claude: command not found"** — Claude Code CLI ist nicht installiert oder nicht im PATH. Siehe [Claude Code Dokumentation](https://code.claude.com/docs/en/overview).
@@ -613,7 +640,7 @@ Beiträge sind willkommen! Bereiche, in denen am meisten Hilfe benötigt wird:
 
 - **Neue Stack-Templates** — Ruby/Rails, Go/Gin, PHP/Laravel, Rust/Axum
 - **Tiefe Monorepo-Unterstützung** — Separate Unterprojekt-Roots, Workspace-Erkennung
-- **Testabdeckung** — Wachsende Testsuite (derzeit 87 Tests für Stack-Erkennung, Domain-Gruppierung, Plan-Validierung, Strukturscan und Verifizierungstools)
+- **Testabdeckung** — Wachsende Testsuite (derzeit 256 Tests für alle Scanner, Stack-Erkennung, Domain-Gruppierung, Plan-Parsing, Prompt-Generierung, CLI-Selektoren, Monorepo-Erkennung und Verifizierungstools)
 
 ---
 

package/README.es.md

@@ -65,14 +65,16 @@ Esta diferencia se acumula. 10 tareas/día × 20 minutos ahorrados = **más de 3
 |---|---|---|
 | **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 |
+| **Node.js / Express** | `package.json` | 9 categorías, 57 sub-ítems |
+| **Node.js / NestJS** | `package.json` (`@nestjs/core`) | 10 categorías, 68 sub-ítems |
+| **Next.js / React** | `package.json`, `next.config.*`, soporte FSD | 9 categorías, 55 sub-ítems |
+| **Vue / Nuxt** | `package.json`, `nuxt.config.*`, Composition API | 9 categorías, 58 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 |
 | **Node.js / Fastify** | `package.json` | 10 categorías, 62 sub-ítems |
 | **Angular** | `package.json`, `angular.json` | 12 categorías, 78 sub-ítems |
 
-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).
+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), monorepo (Turborepo, pnpm-workspace, Lerna, npm/yarn workspaces).
 
 **No necesitas especificar nada. Todo se detecta automáticamente.**
 
@@ -87,7 +89,7 @@ Detección automática: lenguaje y versión, framework y versión, ORM (MyBatis,
 | E | DDD/Hexagonal | `{domain}/adapter/in/web/` | `user/adapter/in/web/UserController.java` |
 | C | Plano | `controller/*.java` | `controller/UserController.java` → extrae `user` del nombre de clase |
 
-Los dominios solo con servicios (sin controladores) también se detectan mediante directorios `service/`, `dao/`, `aggregator/`, `mapper/`, `repository/`. Se omiten: `common`, `config`, `util`, `core`, `front`, `admin`, `v1`, `v2`, etc.
+Los dominios solo con servicios (sin controladores) también se detectan mediante directorios `service/`, `dao/`, `aggregator/`, `facade/`, `usecase/`, `orchestrator/`, `mapper/`, `repository/`. Se omiten: `common`, `config`, `util`, `core`, `front`, `admin`, `v1`, `v2`, etc.
 
 
 ### Detección de Dominios Kotlin Multi-Módulo
@@ -179,6 +181,7 @@ npx claudeos-core init --lang ko    # 한국어
 > **Nota:** Solo cambia el idioma de los archivos de documentación generados. El análisis de código (Pass 1–2) siempre se ejecuta en inglés; solo la salida generada (Pass 3) se escribe en el idioma elegido.
 
 Eso es todo. Después de 5–18 minutos, toda la documentación estará generada y lista para usar.
+El CLI muestra el tiempo transcurrido por cada Pass y el tiempo total en el banner de finalización.
 
 ### Instalación Manual Paso a Paso
 
@@ -527,9 +530,18 @@ Sí, recomendado. Tu equipo puede compartir los mismos estándares de Claude Cod
 **P: ¿Qué pasa con proyectos de stack mixto (ej: backend Java + frontend React)?**
 Totalmente soportado. ClaudeOS-Core auto-detecta ambos stacks, etiqueta dominios como `backend` o `frontend`, y usa prompts de análisis específicos para cada uno. Pass 2 fusiona todo, y Pass 3 genera los estándares de backend y frontend en una sola pasada.
 
+**P: ¿Funciona con Turborepo / pnpm workspaces / monorepos Lerna?**
+Sí. ClaudeOS-Core detecta `turbo.json`, `pnpm-workspace.yaml`, `lerna.json` o `package.json#workspaces` y escanea automáticamente los `package.json` de sub-paquetes en busca de dependencias de framework/ORM/BD. El escaneo de dominios cubre patrones `apps/*/src/` y `packages/*/src/`. Ejecuta desde la raíz del monorepo.
+
 **P: ¿Qué pasa al re-ejecutar?**
 Si existen resultados previos de Pass 1/2, un prompt interactivo te permite elegir: **Continue** (reanudar desde donde se detuvo) o **Fresh** (eliminar todo y empezar de nuevo). Usa `--force` para omitir el prompt y siempre empezar de nuevo. Pass 3 siempre se re-ejecuta. Las versiones anteriores pueden restaurarse desde los Master Plans.
 
+**P: ¿NestJS tiene su propia plantilla o usa la de Express?**
+NestJS usa una plantilla dedicada `node-nestjs` con categorías de análisis específicas de NestJS: decoradores `@Module`, `@Injectable`, `@Controller`, Guards, Pipes, Interceptors, contenedor DI, patrones CQRS y `Test.createTestingModule`. Los proyectos Express usan la plantilla separada `node-express`.
+
+**P: ¿Qué hay de los proyectos Vue / Nuxt?**
+Vue/Nuxt usa una plantilla dedicada `vue-nuxt` que cubre Composition API, `<script setup>`, defineProps/defineEmits, stores Pinia, `useFetch`/`useAsyncData`, rutas de servidor Nitro y `@nuxt/test-utils`. Los proyectos Next.js/React usan la plantilla `node-nextjs`.
+
 **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.).
 
@@ -548,50 +560,66 @@ 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)
+├── node-express/            # Node.js / Express
+├── node-nestjs/             # Node.js / NestJS (Module, DI, Guard, Pipe, Interceptor)
 ├── node-fastify/            # Node.js / Fastify
+├── node-nextjs/             # Next.js / React
+├── vue-nuxt/                # Vue / Nuxt (Composition API, Pinia, Nitro)
 ├── angular/                 # Angular
+├── python-django/           # Python / Django (DRF)
 └── python-fastapi/          # Python / FastAPI
 ```
 
-`plan-installer` auto-detecta tu(s) stack(s) y ensambla prompts específicos por tipo. Para proyectos multi-stack, se generan `pass1-backend-prompt.md` y `pass1-frontend-prompt.md` por separado, mientras que `pass3-prompt.md` combina los objetivos de generación de ambos stacks.
+`plan-installer` auto-detecta tu(s) stack(s) y ensambla prompts específicos por tipo. NestJS y Vue/Nuxt usan plantillas dedicadas con categorías de análisis específicas del framework (ej: `@Module`/`@Injectable`/Guards para NestJS, `<script setup>`/Pinia/useFetch para Vue). Para proyectos multi-stack, se generan `pass1-backend-prompt.md` y `pass1-frontend-prompt.md` por separado, mientras que `pass3-prompt.md` combina los objetivos de generación de ambos stacks.
 
 ---
 
 ## Soporte Monorepo
 
-ClaudeOS-Core lee el `package.json` del **directorio actual**. En configuraciones monorepo (Turborepo, Nx, Lerna, pnpm workspaces), el `package.json` raíz generalmente no contiene dependencias de framework como `next`, `express` o `react` — están en los directorios individuales de cada app.
+ClaudeOS-Core detecta automáticamente configuraciones de monorepo JS/TS y escanea sub-paquetes en busca de dependencias.
 
-**Ejecuta ClaudeOS-Core desde el directorio de la app, no desde la raíz del monorepo:**
+**Marcadores de monorepo soportados** (auto-detectados):
+- `turbo.json` (Turborepo)
+- `pnpm-workspace.yaml` (pnpm workspaces)
+- `lerna.json` (Lerna)
+- `package.json#workspaces` (npm/yarn workspaces)
 
-```bash
-# Ejemplo: Turborepo con apps/my-app
-cd apps/my-app
-npx claudeos-core init
+**Ejecuta desde la raíz del monorepo** — ClaudeOS-Core lee `apps/*/package.json` y `packages/*/package.json` para descubrir dependencias de framework/ORM/BD en los sub-paquetes:
 
-# Ejemplo: Workspace Nx
-cd apps/frontend
+```bash
+cd my-monorepo
 npx claudeos-core init
 ```
 
-Cada app obtiene su propio conjunto independiente de Standards, Rules, Skills y Guides adaptados al stack y patrones de esa app específica.
+**Qué se detecta:**
+- Dependencias de `apps/web/package.json` (ej: `next`, `react`) → stack frontend
+- Dependencias de `apps/api/package.json` (ej: `express`, `prisma`) → stack backend
+- Dependencias de `packages/db/package.json` (ej: `drizzle-orm`) → ORM/BD
+- Rutas de workspace personalizadas desde `pnpm-workspace.yaml` (ej: `services/*`)
 
-**Estructura típica de monorepo:**
+**El escaneo de dominios también cubre layouts de monorepo:**
+- `apps/api/src/modules/*/` y `apps/api/src/*/` para dominios backend
+- `apps/web/app/*/`, `apps/web/src/app/*/`, `apps/web/pages/*/` para dominios frontend
+- `packages/*/src/*/` para dominios de paquetes compartidos
 
 ```
-my-monorepo/                    ← No ejecutes aquí (la raíz no tiene deps de framework)
+my-monorepo/                    ← Ejecuta aquí: npx claudeos-core init
+├── turbo.json                  ← Auto-detectado como Turborepo
 ├── apps/
-│   ├── web/                    ← Ejecuta aquí: cd apps/web && npx claudeos-core init
-│   ├── api/                    ← Ejecuta aquí: cd apps/api && npx claudeos-core init
-│   └── storybook/
+│   ├── web/                    ← Next.js detectado desde apps/web/package.json
+│   │   ├── app/dashboard/      ← Dominio frontend detectado
+│   │   └── package.json        ← { "dependencies": { "next": "^14" } }
+│   └── api/                    ← Express detectado desde apps/api/package.json
+│       ├── src/modules/users/  ← Dominio backend detectado
+│       └── package.json        ← { "dependencies": { "express": "^4" } }
 ├── packages/
-│   ├── ui/
-│   └── utils/
-└── package.json                ← Solo devDependencies (turbo, eslint, etc.)
+│   ├── db/                     ← Drizzle detectado desde packages/db/package.json
+│   └── ui/
+└── package.json                ← { "workspaces": ["apps/*", "packages/*"] }
 ```
 
+> **Nota:** Para monorepos Kotlin/Java, la detección multi-módulo usa `settings.gradle.kts` (ver [Detección de Dominios Kotlin Multi-Módulo](#detección-de-dominios-kotlin-multi-módulo) arriba) y no requiere marcadores de monorepo JS.
+
 ## Solución de Problemas
 
 **"claude: command not found"** — Claude Code CLI no está instalado o no está en el PATH. Consulta la [documentación de Claude Code](https://code.claude.com/docs/en/overview).
@@ -614,7 +642,7 @@ my-monorepo/                    ← No ejecutes aquí (la raíz no tiene deps de
 
 - **Nuevas plantillas de stack** — Ruby/Rails, Go/Gin, PHP/Laravel, Rust/Axum
 - **Soporte profundo para monorepos** — Raíces de sub-proyectos separadas, detección de workspaces
-- **Cobertura de tests** — Suite de tests en expansión (actualmente 87 tests cubriendo detección de stack, agrupación de dominios, validación de planes, escaneo de estructura y herramientas de verificación)
+- **Cobertura de tests** — Suite de tests en expansión (actualmente 256 tests cubriendo todos los scanners, detección de stack, agrupación de dominios, parsing de planes, generación de prompts, selectores CLI, detección de monorepos y herramientas de verificación)
 
 ---
 

package/README.fr.md

@@ -65,14 +65,16 @@ Cette différence s'accumule. 10 tâches/jour × 20 minutes économisées = **pl
 |---|---|---|
 | **Java / Spring Boot** | `build.gradle`, `pom.xml`, 5 patterns de paquets | 10 catégories, 59 sous-éléments |
 | **Kotlin / Spring Boot** | `build.gradle.kts`, kotlin plugin, `settings.gradle.kts`, CQRS/BFF auto-detect | 12 catégories, 95 sous-éléments |
-| **Node.js / Express / NestJS** | `package.json` | 9 catégories, 57 sous-éléments |
-| **Next.js / React / Vue** | `package.json`, `next.config.*`, support FSD | 9 catégories, 55 sous-éléments |
+| **Node.js / Express** | `package.json` | 9 catégories, 57 sous-éléments |
+| **Node.js / NestJS** | `package.json` (`@nestjs/core`) | 10 catégories, 68 sous-éléments |
+| **Next.js / React** | `package.json`, `next.config.*`, support FSD | 9 catégories, 55 sous-éléments |
+| **Vue / Nuxt** | `package.json`, `nuxt.config.*`, Composition API | 9 catégories, 58 sous-éléments |
 | **Python / Django** | `requirements.txt`, `pyproject.toml` | 10 catégories, 55 sous-éléments |
 | **Python / FastAPI** | `requirements.txt`, `pyproject.toml` | 10 catégories, 58 sous-éléments |
 | **Node.js / Fastify** | `package.json` | 10 catégories, 62 sous-éléments |
 | **Angular** | `package.json`, `angular.json` | 12 catégories, 78 sous-éléments |
 
-Détection automatique : langage et version, framework et version, ORM (MyBatis, JPA, Exposed, Prisma, TypeORM, SQLAlchemy, etc.), base de données (PostgreSQL, MySQL, Oracle, MongoDB, SQLite), gestionnaire de paquets (Gradle, Maven, npm, yarn, pnpm, pip, poetry), architecture (CQRS, BFF — détecté à partir des noms de modules), structure multi-module (depuis settings.gradle).
+Détection automatique : langage et version, framework et version, ORM (MyBatis, JPA, Exposed, Prisma, TypeORM, SQLAlchemy, etc.), base de données (PostgreSQL, MySQL, Oracle, MongoDB, SQLite), gestionnaire de paquets (Gradle, Maven, npm, yarn, pnpm, pip, poetry), architecture (CQRS, BFF — détecté à partir des noms de modules), structure multi-module (depuis settings.gradle), monorepo (Turborepo, pnpm-workspace, Lerna, npm/yarn workspaces).
 
 **Vous n'avez rien à spécifier. Tout est détecté automatiquement.**
 
@@ -87,7 +89,7 @@ Détection automatique : langage et version, framework et version, ORM (MyBatis,
 | E | DDD/Hexagonal | `{domain}/adapter/in/web/` | `user/adapter/in/web/UserController.java` |
 | C | Plat | `controller/*.java` | `controller/UserController.java` → extrait `user` du nom de classe |
 
-Les domaines sans contrôleurs (service uniquement) sont aussi détectés via les répertoires `service/`, `dao/`, `aggregator/`, `mapper/`, `repository/`. Ignorés : `common`, `config`, `util`, `core`, `front`, `admin`, `v1`, `v2`, etc.
+Les domaines sans contrôleurs (service uniquement) sont aussi détectés via les répertoires `service/`, `dao/`, `aggregator/`, `facade/`, `usecase/`, `orchestrator/`, `mapper/`, `repository/`. Ignorés : `common`, `config`, `util`, `core`, `front`, `admin`, `v1`, `v2`, etc.
 
 
 ### Détection des domaines Kotlin multi-modules
@@ -179,6 +181,7 @@ npx claudeos-core init --lang ko    # 한국어
 > **Note :** Ceci ne change que la langue des fichiers de documentation générés. L'analyse du code (Pass 1–2) s'exécute toujours en anglais ; seul le résultat généré (Pass 3) est écrit dans la langue choisie.
 
 C'est tout. Après 5–18 minutes, toute la documentation est générée et prête à l'emploi.
+Le CLI affiche le temps écoulé par Pass et le temps total dans la bannière de fin.
 
 ### Installation Manuelle Étape par Étape
 
@@ -527,9 +530,18 @@ Recommandé. Votre équipe peut partager les mêmes standards Claude Code. Envis
 **Q : Qu'en est-il des projets multi-stack (ex : backend Java + frontend React) ?**
 Entièrement supporté. ClaudeOS-Core auto-détecte les deux stacks, étiquette les domaines comme `backend` ou `frontend`, et utilise des prompts d'analyse spécifiques pour chacun. Pass 2 fusionne tout, et Pass 3 génère les standards backend et frontend en un seul pass.
 
+**Q : Fonctionne-t-il avec Turborepo / pnpm workspaces / Lerna ?**
+Oui. ClaudeOS-Core détecte `turbo.json`, `pnpm-workspace.yaml`, `lerna.json` ou `package.json#workspaces` et scanne automatiquement les `package.json` des sous-packages pour les dépendances framework/ORM/BD. Le scan de domaines couvre les patterns `apps/*/src/` et `packages/*/src/`. Exécutez depuis la racine du monorepo.
+
 **Q : Que se passe-t-il lors d'une ré-exécution ?**
 Si des résultats Pass 1/2 précédents existent, un prompt interactif vous permet de choisir : **Continue** (reprendre là où ça s'est arrêté) ou **Fresh** (tout supprimer et repartir de zéro). Utilisez `--force` pour ignorer le prompt et toujours repartir de zéro. Pass 3 est toujours ré-exécuté. Les versions précédentes peuvent être restaurées depuis les Master Plans.
 
+**Q : NestJS a-t-il son propre template ou utilise-t-il celui d'Express ?**
+NestJS utilise un template dédié `node-nestjs` avec des catégories d'analyse spécifiques à NestJS : décorateurs `@Module`, `@Injectable`, `@Controller`, Guards, Pipes, Interceptors, conteneur DI, patterns CQRS et `Test.createTestingModule`. Les projets Express utilisent le template séparé `node-express`.
+
+**Q : Qu'en est-il des projets Vue / Nuxt ?**
+Vue/Nuxt utilise un template dédié `vue-nuxt` couvrant la Composition API, `<script setup>`, defineProps/defineEmits, les stores Pinia, `useFetch`/`useAsyncData`, les routes serveur Nitro et `@nuxt/test-utils`. Les projets Next.js/React utilisent le template `node-nextjs`.
+
 **Q : Kotlin est-il supporté ?**
 Oui. ClaudeOS-Core détecte automatiquement Kotlin à partir de `build.gradle.kts` ou du plugin kotlin dans `build.gradle`. Il utilise un template dédié `kotlin-spring` avec une analyse spécifique à Kotlin (data classes, sealed classes, coroutines, fonctions d'extension, MockK, etc.).
 
@@ -548,50 +560,66 @@ pass-prompts/templates/
 ├── common/                  # En-tête/pied de page partagés
 ├── 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)
+├── node-express/            # Node.js / Express
+├── node-nestjs/             # Node.js / NestJS (Module, DI, Guard, Pipe, Interceptor)
 ├── node-fastify/            # Node.js / Fastify
+├── node-nextjs/             # Next.js / React
+├── vue-nuxt/                # Vue / Nuxt (Composition API, Pinia, Nitro)
 ├── angular/                 # Angular
+├── python-django/           # Python / Django (DRF)
 └── python-fastapi/          # Python / FastAPI
 ```
 
-`plan-installer` auto-détecte votre/vos stack(s) puis assemble des prompts spécifiques au type. Pour les projets multi-stack, `pass1-backend-prompt.md` et `pass1-frontend-prompt.md` sont générés séparément, tandis que `pass3-prompt.md` combine les cibles de génération des deux stacks.
+`plan-installer` auto-détecte votre/vos stack(s) puis assemble des prompts spécifiques au type. NestJS et Vue/Nuxt utilisent des templates dédiés avec des catégories d'analyse spécifiques au framework (ex : `@Module`/`@Injectable`/Guards pour NestJS, `<script setup>`/Pinia/useFetch pour Vue). Pour les projets multi-stack, `pass1-backend-prompt.md` et `pass1-frontend-prompt.md` sont générés séparément, tandis que `pass3-prompt.md` combine les cibles de génération des deux stacks.
 
 ---
 
 ## Support Monorepo
 
-ClaudeOS-Core lit le `package.json` du **répertoire courant**. Dans les configurations monorepo (Turborepo, Nx, Lerna, pnpm workspaces), le `package.json` racine ne contient généralement pas les dépendances de framework comme `next`, `express` ou `react` — elles se trouvent dans les répertoires individuels des applications.
+ClaudeOS-Core détecte automatiquement les configurations monorepo JS/TS et scanne les sous-packages pour les dépendances.
 
-**Exécutez ClaudeOS-Core depuis le répertoire de l'application, pas depuis la racine du monorepo :**
+**Marqueurs monorepo supportés** (auto-détectés) :
+- `turbo.json` (Turborepo)
+- `pnpm-workspace.yaml` (pnpm workspaces)
+- `lerna.json` (Lerna)
+- `package.json#workspaces` (npm/yarn workspaces)
 
-```bash
-# Exemple : Turborepo avec apps/my-app
-cd apps/my-app
-npx claudeos-core init
+**Exécutez depuis la racine du monorepo** — ClaudeOS-Core lit `apps/*/package.json` et `packages/*/package.json` pour découvrir les dépendances framework/ORM/BD dans les sous-packages :
 
-# Exemple : Workspace Nx
-cd apps/frontend
+```bash
+cd my-monorepo
 npx claudeos-core init
 ```
 
-Chaque application obtient son propre ensemble indépendant de Standards, Rules, Skills et Guides adaptés au stack et aux patterns de cette application spécifique.
+**Ce qui est détecté :**
+- Dépendances de `apps/web/package.json` (ex : `next`, `react`) → stack frontend
+- Dépendances de `apps/api/package.json` (ex : `express`, `prisma`) → stack backend
+- Dépendances de `packages/db/package.json` (ex : `drizzle-orm`) → ORM/BD
+- Chemins de workspace personnalisés depuis `pnpm-workspace.yaml` (ex : `services/*`)
 
-**Structure monorepo typique :**
+**Le scan de domaines couvre aussi les structures monorepo :**
+- `apps/api/src/modules/*/` et `apps/api/src/*/` pour les domaines backend
+- `apps/web/app/*/`, `apps/web/src/app/*/`, `apps/web/pages/*/` pour les domaines frontend
+- `packages/*/src/*/` pour les domaines des packages partagés
 
 ```
-my-monorepo/                    ← Ne pas exécuter ici (la racine n'a pas de deps framework)
+my-monorepo/                    ← Exécuter ici : npx claudeos-core init
+├── turbo.json                  ← Auto-détecté comme Turborepo
 ├── apps/
-│   ├── web/                    ← Exécuter ici : cd apps/web && npx claudeos-core init
-│   ├── api/                    ← Exécuter ici : cd apps/api && npx claudeos-core init
-│   └── storybook/
+│   ├── web/                    ← Next.js détecté depuis apps/web/package.json
+│   │   ├── app/dashboard/      ← Domaine frontend détecté
+│   │   └── package.json        ← { "dependencies": { "next": "^14" } }
+│   └── api/                    ← Express détecté depuis apps/api/package.json
+│       ├── src/modules/users/  ← Domaine backend détecté
+│       └── package.json        ← { "dependencies": { "express": "^4" } }
 ├── packages/
-│   ├── ui/
-│   └── utils/
-└── package.json                ← Seulement devDependencies (turbo, eslint, etc.)
+│   ├── db/                     ← Drizzle détecté depuis packages/db/package.json
+│   └── ui/
+└── package.json                ← { "workspaces": ["apps/*", "packages/*"] }
 ```
 
+> **Note :** Pour les monorepos Kotlin/Java, la détection multi-modules utilise `settings.gradle.kts` (voir [Détection des domaines Kotlin multi-modules](#détection-des-domaines-kotlin-multi-modules) ci-dessus) et ne nécessite pas de marqueurs monorepo JS.
+
 ## Dépannage
 
 **"claude: command not found"** — Claude Code CLI n'est pas installé ou pas dans le PATH. Voir la [documentation Claude Code](https://code.claude.com/docs/en/overview).
@@ -614,7 +642,7 @@ Les contributions sont les bienvenues ! Domaines où l'aide est la plus nécessa
 
 - **Nouveaux templates de stack** — Ruby/Rails, Go/Gin, PHP/Laravel, Rust/Axum
 - **Support approfondi monorepo** — Racines de sous-projets séparées, détection de workspaces
-- **Couverture de tests** — Suite de tests en expansion (actuellement 87 tests couvrant la détection de stack, le groupement de domaines, la validation de plans, le scan de structure et les outils de vérification)
+- **Couverture de tests** — Suite de tests en expansion (actuellement 256 tests couvrant tous les scanners, la détection de stack, le groupement de domaines, le parsing de plans, la génération de prompts, les sélecteurs CLI, la détection de monorepos et les outils de vérification)
 
 ---